1261 lines (1260 with data), 198.3 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {
        "id": "2l9DnvglyqMl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "e07e9c3d-c482-4615-8f1d-8b8f9cbefac6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1693428235.0125127\n",
            "Wed Aug 30 20:43:55 2023\n"
          ]
        }
      ],
      "source": [
        "# This cell is added by sphinx-gallery\n",
        "# It can be customized to whatever you like\n",
        "%matplotlib inline\n",
        "# from google.colab import drive\n",
        "# drive.mount('/content/drive')\n",
        "# !pip install pennylane\n",
        "import time\n",
        "seconds = time.time()\n",
        "print(\"Time in seconds since beginning of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5uiLxJB3yqMm"
      },
      "source": [
        "Variational classifier {#variational_classifier}\n",
        "======================\n",
        "\n",
        "::: {.meta}\n",
        ":property=\\\"og:description\\\": Using PennyLane to implement quantum\n",
        "circuits that can be trained from labelled data to classify new data\n",
        "samples. :property=\\\"og:image\\\":\n",
        "<https://pennylane.ai/qml/_images/classifier_output_59_0.png>\n",
        ":::\n",
        "\n",
        "::: {.related}\n",
        "tutorial\\_data\\_reuploading\\_classifier Data-reuploading classifier\n",
        "tutorial\\_multiclass\\_classification Multiclass margin classifier\n",
        "ensemble\\_multi\\_qpu Ensemble classification with Rigetti and Qiskit\n",
        "devices\n",
        ":::\n",
        "\n",
        "*Author: Maria Schuld --- Posted: 11 October 2019. Last updated: 19\n",
        "January 2021.*\n",
        "\n",
        "In this tutorial, we show how to use PennyLane to implement variational\n",
        "quantum classifiers - quantum circuits that can be trained from labelled\n",
        "data to classify new data samples. The architecture is inspired by\n",
        "[Farhi and Neven (2018)](https://arxiv.org/abs/1802.06002) as well as\n",
        "[Schuld et al. (2018)](https://arxiv.org/abs/1804.00633).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ue7hv7qSyqMn"
      },
      "source": [
        "We will first show that the variational quantum classifier can reproduce\n",
        "the parity function\n",
        "\n",
        "$$\\begin{aligned}\n",
        "f: x \\in \\{0,1\\}^{\\otimes n} \\rightarrow y =\n",
        "\\begin{cases} 1 \\text{  if uneven number of ones in } x \\\\ 0\n",
        "\\text{ otherwise} \\end{cases}.\n",
        "\\end{aligned}$$\n",
        "\n",
        "This optimization example demonstrates how to encode binary inputs into\n",
        "the initial state of the variational circuit, which is simply a\n",
        "computational basis state.\n",
        "\n",
        "We then show how to encode real vectors as amplitude vectors (*amplitude\n",
        "encoding*) and train the model to recognize the first two classes of\n",
        "flowers in the Iris dataset.\n",
        "\n",
        "1. Fitting the parity function\n",
        "==============================\n",
        "\n",
        "Imports\n",
        "-------\n",
        "\n",
        "As before, we import PennyLane, the PennyLane-provided version of NumPy,\n",
        "and an optimizer.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {
        "id": "S4C7r4lhyqMn"
      },
      "outputs": [],
      "source": [
        "import pennylane as qml\n",
        "from pennylane import numpy as np\n",
        "from pennylane.optimize import NesterovMomentumOptimizer"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBtbLq8NyqMn"
      },
      "source": [
        "Quantum and classical nodes\n",
        "===========================\n",
        "\n",
        "We create a quantum device with four \"wires\" (or qubits).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 102,
      "metadata": {
        "id": "_siB9XyLyqMn"
      },
      "outputs": [],
      "source": [
        "dev = qml.device(\"default.qubit\", wires=4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fKNBHNQRyqMn"
      },
      "source": [
        "Variational classifiers usually define a \"layer\" or \"block\", which is an\n",
        "elementary circuit architecture that gets repeated to build the\n",
        "variational circuit.\n",
        "\n",
        "Our circuit layer consists of an arbitrary rotation on every qubit, as\n",
        "well as CNOTs that entangle each qubit with its neighbour.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {
        "id": "8EteJ3M1yqMn"
      },
      "outputs": [],
      "source": [
        "def layer(W):\n",
        "\n",
        "    qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)\n",
        "    qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)\n",
        "    qml.Rot(W[2, 0], W[2, 1], W[2, 2], wires=2)\n",
        "    qml.Rot(W[3, 0], W[3, 1], W[3, 2], wires=3)\n",
        "\n",
        "    qml.CNOT(wires=[0, 1])\n",
        "    qml.CNOT(wires=[1, 2])\n",
        "    qml.CNOT(wires=[2, 3])\n",
        "    qml.CNOT(wires=[3, 0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O_uRpKLoyqMn"
      },
      "source": [
        "We also need a way to encode data inputs $x$ into the circuit, so that\n",
        "the measured output depends on the inputs. In this first example, the\n",
        "inputs are bitstrings, which we encode into the state of the qubits. The\n",
        "quantum state $\\psi$ after state preparation is a computational basis\n",
        "state that has 1s where $x$ has 1s, for example\n",
        "\n",
        "$$x = 0101 \\rightarrow |\\psi \\rangle = |0101 \\rangle .$$\n",
        "\n",
        "We use the `~pennylane.BasisState`{.interpreted-text role=\"class\"}\n",
        "function provided by PennyLane, which expects `x` to be a list of zeros\n",
        "and ones, i.e. `[0,1,0,1]`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {
        "id": "KHPeGH3DyqMn"
      },
      "outputs": [],
      "source": [
        "def statepreparation(x):\n",
        "    qml.BasisState(x, wires=[0, 1, 2, 3])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pk3ofHMEyqMo"
      },
      "source": [
        "Now we define the quantum node as a state preparation routine, followed\n",
        "by a repetition of the layer structure. Borrowing from machine learning,\n",
        "we call the parameters `weights`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {
        "id": "JRXd4rFwyqMo"
      },
      "outputs": [],
      "source": [
        "@qml.qnode(dev, interface=\"autograd\")\n",
        "def circuit(weights, x):\n",
        "\n",
        "    statepreparation(x)\n",
        "\n",
        "    for W in weights:\n",
        "        layer(W)\n",
        "\n",
        "    return qml.expval(qml.PauliZ(0))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "he4KqfSnyqMo"
      },
      "source": [
        "Different from previous examples, the quantum node takes the data as a\n",
        "keyword argument `x` (with the default value `None`). Keyword arguments\n",
        "of a quantum node are considered as fixed when calculating a gradient;\n",
        "they are never trained.\n",
        "\n",
        "If we want to add a \"classical\" bias parameter, the variational quantum\n",
        "classifier also needs some post-processing. We define the final model by\n",
        "a classical node that uses the first variable, and feeds the remainder\n",
        "into the quantum node. Before this, we reshape the list of remaining\n",
        "variables for easy use in the quantum node.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 106,
      "metadata": {
        "id": "XvhxkBOoyqMo"
      },
      "outputs": [],
      "source": [
        "def variational_classifier(weights, bias, x):\n",
        "    return circuit(weights, x) + bias"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sco3rPabyqMo"
      },
      "source": [
        "Cost\n",
        "====\n",
        "\n",
        "In supervised learning, the cost function is usually the sum of a loss\n",
        "function and a regularizer. We use the standard square loss that\n",
        "measures the distance between target labels and model predictions.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {
        "id": "NnlX2dBPyqMo"
      },
      "outputs": [],
      "source": [
        "def square_loss(labels, predictions):\n",
        "    loss = 0\n",
        "    for l, p in zip(labels, predictions):\n",
        "        loss = loss + (l - p) ** 2\n",
        "\n",
        "    loss = loss / len(labels)\n",
        "    return loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qs39RtaayqMo"
      },
      "source": [
        "To monitor how many inputs the current classifier predicted correctly,\n",
        "we also define the accuracy given target labels and model predictions.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {
        "id": "WwPgFt7pyqMo"
      },
      "outputs": [],
      "source": [
        "def accuracy(labels, predictions):\n",
        "\n",
        "    loss = 0\n",
        "    for l, p in zip(labels, predictions):\n",
        "        if abs(l - p) < 1e-5:\n",
        "            loss = loss + 1\n",
        "    loss = loss / len(labels)\n",
        "\n",
        "    return loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DZQFl81vyqMo"
      },
      "source": [
        "For learning tasks, the cost depends on the data - here the features and\n",
        "labels considered in the iteration of the optimization routine.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 109,
      "metadata": {
        "id": "OPzeeAKayqMo"
      },
      "outputs": [],
      "source": [
        "def cost(weights, bias, X, Y):\n",
        "    predictions = [variational_classifier(weights, bias, x) for x in X]\n",
        "    return square_loss(Y, predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uo3I0i-gyqMo"
      },
      "source": [
        "Optimization\n",
        "============\n",
        "\n",
        "Let's now load and preprocess some data.\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "The parity dataset can be downloaded\n",
        "`<a href=\"https://raw.githubusercontent.com/XanaduAI/qml/master/demonstrations/variational_classifier/data/parity.txt\"\n",
        "download=parity.txt target=\"_blank\">here</a>`{.interpreted-text\n",
        "role=\"html\"} and should be placed in the subfolder\n",
        "`variational_classifier/data`.\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 110,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "yiXUCgY2yqMo",
        "outputId": "e42d842c-17ff-4d50-e13f-f679f74714cf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X = [0. 0. 0. 0.], Y = -1\n",
            "X = [0. 0. 0. 1.], Y =  1\n",
            "X = [0. 0. 1. 0.], Y =  1\n",
            "X = [0. 0. 1. 1.], Y = -1\n",
            "X = [0. 1. 0. 0.], Y =  1\n",
            "...\n"
          ]
        }
      ],
      "source": [
        "data = np.loadtxt(\"/content/drive/MyDrive/Colab Notebooks/data/parity.txt\")\n",
        "X = np.array(data[:, :-1], requires_grad=False)\n",
        "Y = np.array(data[:, -1], requires_grad=False)\n",
        "Y = Y * 2 - np.ones(len(Y))  # shift label from {0, 1} to {-1, 1}\n",
        "\n",
        "for i in range(5):\n",
        "    print(\"X = {}, Y = {: d}\".format(X[i], int(Y[i])))\n",
        "\n",
        "print(\"...\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xaXn9xmwyqMo"
      },
      "source": [
        "We initialize the variables randomly (but fix a seed for\n",
        "reproducibility). The first variable in the list is used as a bias,\n",
        "while the rest is fed into the gates of the variational circuit.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "OOnioR90yqMo",
        "outputId": "e9c9bcdc-b178-4021-a75a-0fe0af9bff94"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[ 0.01764052  0.00400157  0.00978738]\n",
            "  [ 0.02240893  0.01867558 -0.00977278]\n",
            "  [ 0.00950088 -0.00151357 -0.00103219]\n",
            "  [ 0.00410599  0.00144044  0.01454274]]\n",
            "\n",
            " [[ 0.00761038  0.00121675  0.00443863]\n",
            "  [ 0.00333674  0.01494079 -0.00205158]\n",
            "  [ 0.00313068 -0.00854096 -0.0255299 ]\n",
            "  [ 0.00653619  0.00864436 -0.00742165]]] 0.0\n"
          ]
        }
      ],
      "source": [
        "np.random.seed(0)\n",
        "num_qubits = 4\n",
        "num_layers = 2\n",
        "weights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)\n",
        "bias_init = np.array(0.0, requires_grad=True)\n",
        "\n",
        "print(weights_init, bias_init)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j623eUSUyqMp"
      },
      "source": [
        "Next we create an optimizer and choose a batch size...\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 112,
      "metadata": {
        "id": "s36xsyg9yqMp"
      },
      "outputs": [],
      "source": [
        "opt = NesterovMomentumOptimizer(0.5)\n",
        "batch_size = 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENjwgp7ryqMp"
      },
      "source": [
        "...and train the optimizer. We track the accuracy - the share of\n",
        "correctly classified data samples. For this we compute the outputs of\n",
        "the variational classifier and turn them into predictions in $\\{-1,1\\}$\n",
        "by taking the sign of the output.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Q4mKVvUbyqMp",
        "outputId": "ae83a460-9125-4c73-b277-5fc46352a816"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iter:     1 | Cost: 3.4355534 | Accuracy: 0.5000000 \n",
            "Iter:     2 | Cost: 1.9717733 | Accuracy: 0.5000000 \n",
            "Iter:     3 | Cost: 1.8182812 | Accuracy: 0.5000000 \n",
            "Iter:     4 | Cost: 1.5042404 | Accuracy: 0.5000000 \n",
            "Iter:     5 | Cost: 1.1477739 | Accuracy: 0.5000000 \n",
            "Iter:     6 | Cost: 1.2734990 | Accuracy: 0.6250000 \n",
            "Iter:     7 | Cost: 0.8290628 | Accuracy: 0.5000000 \n",
            "Iter:     8 | Cost: 0.3226183 | Accuracy: 1.0000000 \n",
            "Iter:     9 | Cost: 0.1436206 | Accuracy: 1.0000000 \n",
            "Iter:    10 | Cost: 0.2982810 | Accuracy: 1.0000000 \n",
            "Iter:    11 | Cost: 0.3064355 | Accuracy: 1.0000000 \n",
            "Iter:    12 | Cost: 0.1682335 | Accuracy: 1.0000000 \n",
            "Iter:    13 | Cost: 0.0892512 | Accuracy: 1.0000000 \n",
            "Iter:    14 | Cost: 0.0381562 | Accuracy: 1.0000000 \n",
            "Iter:    15 | Cost: 0.0170359 | Accuracy: 1.0000000 \n",
            "Iter:    16 | Cost: 0.0109353 | Accuracy: 1.0000000 \n",
            "Iter:    17 | Cost: 0.0108388 | Accuracy: 1.0000000 \n",
            "Iter:    18 | Cost: 0.0139196 | Accuracy: 1.0000000 \n",
            "Iter:    19 | Cost: 0.0123980 | Accuracy: 1.0000000 \n",
            "Iter:    20 | Cost: 0.0085416 | Accuracy: 1.0000000 \n",
            "Iter:    21 | Cost: 0.0053549 | Accuracy: 1.0000000 \n",
            "Iter:    22 | Cost: 0.0065759 | Accuracy: 1.0000000 \n",
            "Iter:    23 | Cost: 0.0024883 | Accuracy: 1.0000000 \n",
            "Iter:    24 | Cost: 0.0029102 | Accuracy: 1.0000000 \n",
            "Iter:    25 | Cost: 0.0023471 | Accuracy: 1.0000000 \n"
          ]
        }
      ],
      "source": [
        "weights = weights_init\n",
        "bias = bias_init\n",
        "for it in range(25):\n",
        "\n",
        "    # Update the weights by one optimizer step\n",
        "    batch_index = np.random.randint(0, len(X), (batch_size,))\n",
        "    X_batch = X[batch_index]\n",
        "    Y_batch = Y[batch_index]\n",
        "    weights, bias, _, _ = opt.step(cost, weights, bias, X_batch, Y_batch)\n",
        "\n",
        "    # Compute accuracy\n",
        "    predictions = [np.sign(variational_classifier(weights, bias, x)) for x in X]\n",
        "    acc = accuracy(Y, predictions)\n",
        "\n",
        "    print(\n",
        "        \"Iter: {:5d} | Cost: {:0.7f} | Accuracy: {:0.7f} \".format(\n",
        "            it + 1, cost(weights, bias, X, Y), acc\n",
        "        )\n",
        "    )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0RaIFiaJyqMp"
      },
      "source": [
        "2. Iris classification\n",
        "======================\n",
        "\n",
        "Quantum and classical nodes\n",
        "---------------------------\n",
        "\n",
        "To encode real-valued vectors into the amplitudes of a quantum state, we\n",
        "use a 2-qubit simulator.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 114,
      "metadata": {
        "id": "dgMVATiZyqMp"
      },
      "outputs": [],
      "source": [
        "dev = qml.device(\"default.qubit\", wires=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1eU6RuHayqMp"
      },
      "source": [
        "State preparation is not as simple as when we represent a bitstring with\n",
        "a basis state. Every input x has to be translated into a set of angles\n",
        "which can get fed into a small routine for state preparation. To\n",
        "simplify things a bit, we will work with data from the positive\n",
        "subspace, so that we can ignore signs (which would require another\n",
        "cascade of rotations around the z axis).\n",
        "\n",
        "The circuit is coded according to the scheme in [Möttönen, et al.\n",
        "(2004)](https://arxiv.org/abs/quant-ph/0407010), or---as presented for\n",
        "positive vectors only---in [Schuld and Petruccione\n",
        "(2018)](https://link.springer.com/book/10.1007/978-3-319-96424-9). We\n",
        "had to also decompose controlled Y-axis rotations into more basic\n",
        "circuits following [Nielsen and Chuang\n",
        "(2010)](http://www.michaelnielsen.org/qcqi/).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {
        "id": "NrZqQA9ayqMp"
      },
      "outputs": [],
      "source": [
        "def get_angles(x):\n",
        "\n",
        "    beta0 = 2 * np.arcsin(np.sqrt(x[1] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12))\n",
        "    beta1 = 2 * np.arcsin(np.sqrt(x[3] ** 2) / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12))\n",
        "    beta2 = 2 * np.arcsin(\n",
        "        np.sqrt(x[2] ** 2 + x[3] ** 2)\n",
        "        / np.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2)\n",
        "    )\n",
        "\n",
        "    return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])\n",
        "\n",
        "\n",
        "def statepreparation(a):\n",
        "    qml.RY(a[0], wires=0)\n",
        "\n",
        "    qml.CNOT(wires=[0, 1])\n",
        "    qml.RY(a[1], wires=1)\n",
        "    qml.CNOT(wires=[0, 1])\n",
        "    qml.RY(a[2], wires=1)\n",
        "\n",
        "    qml.PauliX(wires=0)\n",
        "    qml.CNOT(wires=[0, 1])\n",
        "    qml.RY(a[3], wires=1)\n",
        "    qml.CNOT(wires=[0, 1])\n",
        "    qml.RY(a[4], wires=1)\n",
        "    qml.PauliX(wires=0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C5WihgOGyqMp"
      },
      "source": [
        "Let's test if this routine actually works.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 116,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "YtpiSIgbyqMp",
        "outputId": "72607e8c-246e-45c5-edf9-266299b5f3ad"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x               :  [0.53896774 0.79503606 0.27826503 0.        ]\n",
            "angles          :  [ 0.56397465 -0.          0.         -0.97504604  0.97504604]\n",
            "amplitude vector:  [ 5.38967743e-01  7.95036065e-01  2.78265032e-01 -2.77555756e-17]\n"
          ]
        }
      ],
      "source": [
        "x = np.array([0.53896774, 0.79503606, 0.27826503, 0.0], requires_grad=False)\n",
        "ang = get_angles(x)\n",
        "\n",
        "\n",
        "@qml.qnode(dev, interface=\"autograd\")\n",
        "def test(angles):\n",
        "\n",
        "    statepreparation(angles)\n",
        "\n",
        "    return qml.expval(qml.PauliZ(0))\n",
        "\n",
        "\n",
        "test(ang)\n",
        "\n",
        "print(\"x               : \", x)\n",
        "print(\"angles          : \", ang)\n",
        "print(\"amplitude vector: \", np.real(dev.state))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-um7c47nyqMp"
      },
      "source": [
        "Note that the `default.qubit` simulator provides a shortcut to\n",
        "`statepreparation` with the command\n",
        "`qml.QubitStateVector(x, wires=[0, 1])`. However, some devices may not\n",
        "support an arbitrary state-preparation routine.\n",
        "\n",
        "Since we are working with only 2 qubits now, we need to update the layer\n",
        "function as well.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {
        "id": "Qvk9iYkPyqMp"
      },
      "outputs": [],
      "source": [
        "def layer(W):\n",
        "    qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)\n",
        "    qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)\n",
        "    qml.CNOT(wires=[0, 1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "917eTFwLyqMp"
      },
      "source": [
        "The variational classifier model and its cost remain essentially the\n",
        "same, but we have to reload them with the new state preparation and\n",
        "layer functions.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 118,
      "metadata": {
        "id": "_77ORtToyqMp"
      },
      "outputs": [],
      "source": [
        "@qml.qnode(dev, interface=\"autograd\")\n",
        "def circuit(weights, angles):\n",
        "    statepreparation(angles)\n",
        "\n",
        "    for W in weights:\n",
        "        layer(W)\n",
        "\n",
        "    return qml.expval(qml.PauliZ(0))\n",
        "\n",
        "\n",
        "def variational_classifier(weights, bias, angles):\n",
        "    return circuit(weights, angles) + bias\n",
        "\n",
        "\n",
        "def cost(weights, bias, features, labels):\n",
        "    predictions = [variational_classifier(weights, bias, f) for f in features]\n",
        "    return square_loss(labels, predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wvWcoKcUyqMp"
      },
      "source": [
        "Data\n",
        "====\n",
        "\n",
        "We then load the Iris data set. There is a bit of preprocessing to do in\n",
        "order to encode the inputs into the amplitudes of a quantum state. In\n",
        "the last preprocessing step, we translate the inputs x to rotation\n",
        "angles using the `get_angles` function we defined above.\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "The Iris dataset can be downloaded\n",
        "`<a href=\"https://raw.githubusercontent.com/XanaduAI/qml/master/demonstrations/variational_classifier/data/iris_classes1and2_scaled.txt\"\n",
        "download=parity.txt target=\"_blank\">here</a>`{.interpreted-text\n",
        "role=\"html\"} and should be placed in the subfolder\n",
        "`variational_classifer/data`.\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "et3_Zr0NyqM3",
        "outputId": "e6ae8814-499a-44a9-e20d-2c875407dc98"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First X sample (original)  : [0.4  0.75]\n",
            "First X sample (padded)    : [0.4  0.75 0.3  0.  ]\n",
            "First X sample (normalized): [0.44376016 0.83205029 0.33282012 0.        ]\n",
            "First features sample      : [ 0.67858523 -0.          0.         -1.080839    1.080839  ]\n"
          ]
        }
      ],
      "source": [
        "data = np.loadtxt(\"/content/drive/MyDrive/Colab Notebooks/data/iris_classes1and2_scaled.txt\")\n",
        "X = data[:, 0:2]\n",
        "print(\"First X sample (original)  :\", X[0])\n",
        "\n",
        "# pad the vectors to size 2^2 with constant values\n",
        "padding = 0.3 * np.ones((len(X), 1))\n",
        "X_pad = np.c_[np.c_[X, padding], np.zeros((len(X), 1))]\n",
        "print(\"First X sample (padded)    :\", X_pad[0])\n",
        "\n",
        "# normalize each input\n",
        "normalization = np.sqrt(np.sum(X_pad ** 2, -1))\n",
        "X_norm = (X_pad.T / normalization).T\n",
        "print(\"First X sample (normalized):\", X_norm[0])\n",
        "\n",
        "# angles for state preparation are new features\n",
        "features = np.array([get_angles(x) for x in X_norm], requires_grad=False)\n",
        "print(\"First features sample      :\", features[0])\n",
        "\n",
        "Y = data[:, -1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zMijswcpyqM3"
      },
      "source": [
        "These angles are our new features, which is why we have renamed X to\n",
        "\"features\" above. Let's plot the stages of preprocessing and play around\n",
        "with the dimensions (dim1, dim2). Some of them still separate the\n",
        "classes well, while others are less informative.\n",
        "\n",
        "*Note: To run the following code you need the matplotlib library.*\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1322
        },
        "id": "QgntUWEUyqM3",
        "outputId": "c5d39c18-be2a-4014-80e1-20f5c8b7819d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure()\n",
        "plt.scatter(X[:, 0][Y == 1], X[:, 1][Y == 1], c=\"b\", marker=\"o\", edgecolors=\"k\")\n",
        "plt.scatter(X[:, 0][Y == -1], X[:, 1][Y == -1], c=\"r\", marker=\"o\", edgecolors=\"k\")\n",
        "plt.title(\"Original data\")\n",
        "plt.show()\n",
        "\n",
        "plt.figure()\n",
        "dim1 = 0\n",
        "dim2 = 1\n",
        "plt.scatter(\n",
        "    X_norm[:, dim1][Y == 1], X_norm[:, dim2][Y == 1], c=\"b\", marker=\"o\", edgecolors=\"k\"\n",
        ")\n",
        "plt.scatter(\n",
        "    X_norm[:, dim1][Y == -1], X_norm[:, dim2][Y == -1], c=\"r\", marker=\"o\", edgecolors=\"k\"\n",
        ")\n",
        "plt.title(\"Padded and normalised data (dims {} and {})\".format(dim1, dim2))\n",
        "plt.show()\n",
        "\n",
        "plt.figure()\n",
        "dim1 = 0\n",
        "dim2 = 3\n",
        "plt.scatter(\n",
        "    features[:, dim1][Y == 1], features[:, dim2][Y == 1], c=\"b\", marker=\"o\", edgecolors=\"k\"\n",
        ")\n",
        "plt.scatter(\n",
        "    features[:, dim1][Y == -1], features[:, dim2][Y == -1], c=\"r\", marker=\"o\", edgecolors=\"k\"\n",
        ")\n",
        "plt.title(\"Feature vectors (dims {} and {})\".format(dim1, dim2))\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TxCo27TgyqM3"
      },
      "source": [
        "This time we want to generalize from the data samples. To monitor the\n",
        "generalization performance, the data is split into training and\n",
        "validation set.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "id": "UcsJlhOpyqM4"
      },
      "outputs": [],
      "source": [
        "np.random.seed(0)\n",
        "num_data = len(Y)\n",
        "num_train = int(0.75 * num_data)\n",
        "index = np.random.permutation(range(num_data))\n",
        "feats_train = features[index[:num_train]]\n",
        "Y_train = Y[index[:num_train]]\n",
        "feats_val = features[index[num_train:]]\n",
        "Y_val = Y[index[num_train:]]\n",
        "\n",
        "# We need these later for plotting\n",
        "X_train = X[index[:num_train]]\n",
        "X_val = X[index[num_train:]]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xjGPKWISyqM4"
      },
      "source": [
        "Optimization\n",
        "============\n",
        "\n",
        "First we initialize the variables.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {
        "id": "MklsrHJcyqM4"
      },
      "outputs": [],
      "source": [
        "num_qubits = 2\n",
        "num_layers = 8\n",
        "\n",
        "weights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)\n",
        "bias_init = np.array(0.0, requires_grad=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VQtBYXZgyqM4"
      },
      "source": [
        "Again we optimize the cost. This may take a little patience.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "je5m-mNCyqM4",
        "outputId": "743cd8a0-28e1-4546-c852-a60157e54142"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iter:     1 | Cost: 1.4094087 | Acc train: 0.4933333 | Acc validation: 0.5600000 \n",
            "Iter:     2 | Cost: 1.2432119 | Acc train: 0.4800000 | Acc validation: 0.5600000 \n",
            "Iter:     3 | Cost: 1.0814080 | Acc train: 0.4666667 | Acc validation: 0.5600000 \n",
            "Iter:     4 | Cost: 0.9459099 | Acc train: 0.5066667 | Acc validation: 0.6000000 \n",
            "Iter:     5 | Cost: 0.8758859 | Acc train: 0.5733333 | Acc validation: 0.7600000 \n",
            "Iter:     6 | Cost: 0.8307530 | Acc train: 0.6800000 | Acc validation: 0.7600000 \n",
            "Iter:     7 | Cost: 0.7978446 | Acc train: 0.7733333 | Acc validation: 0.8800000 \n",
            "Iter:     8 | Cost: 0.7727159 | Acc train: 0.8000000 | Acc validation: 0.9600000 \n",
            "Iter:     9 | Cost: 0.7553697 | Acc train: 0.7733333 | Acc validation: 0.8000000 \n",
            "Iter:    10 | Cost: 0.7795582 | Acc train: 0.6666667 | Acc validation: 0.7600000 \n",
            "Iter:    11 | Cost: 0.7840372 | Acc train: 0.6533333 | Acc validation: 0.7200000 \n",
            "Iter:    12 | Cost: 0.8022080 | Acc train: 0.6266667 | Acc validation: 0.6400000 \n",
            "Iter:    13 | Cost: 0.8129816 | Acc train: 0.6266667 | Acc validation: 0.6400000 \n",
            "Iter:    14 | Cost: 0.7855558 | Acc train: 0.6400000 | Acc validation: 0.6400000 \n",
            "Iter:    15 | Cost: 0.7334577 | Acc train: 0.7333333 | Acc validation: 0.7600000 \n",
            "Iter:    16 | Cost: 0.7085147 | Acc train: 0.8133333 | Acc validation: 0.9200000 \n",
            "Iter:    17 | Cost: 0.7108967 | Acc train: 0.8800000 | Acc validation: 0.9600000 \n",
            "Iter:    18 | Cost: 0.7231977 | Acc train: 0.8400000 | Acc validation: 0.7200000 \n",
            "Iter:    19 | Cost: 0.7793079 | Acc train: 0.5200000 | Acc validation: 0.4400000 \n",
            "Iter:    20 | Cost: 0.7832669 | Acc train: 0.5200000 | Acc validation: 0.4400000 \n",
            "Iter:    21 | Cost: 0.7709443 | Acc train: 0.5466667 | Acc validation: 0.4400000 \n",
            "Iter:    22 | Cost: 0.7277404 | Acc train: 0.6933333 | Acc validation: 0.6400000 \n",
            "Iter:    23 | Cost: 0.7003134 | Acc train: 0.9066667 | Acc validation: 0.9200000 \n",
            "Iter:    24 | Cost: 0.6873190 | Acc train: 0.8933333 | Acc validation: 1.0000000 \n",
            "Iter:    25 | Cost: 0.6821223 | Acc train: 0.8933333 | Acc validation: 1.0000000 \n",
            "Iter:    26 | Cost: 0.6765371 | Acc train: 0.9200000 | Acc validation: 1.0000000 \n",
            "Iter:    27 | Cost: 0.6792595 | Acc train: 0.9066667 | Acc validation: 0.9200000 \n",
            "Iter:    28 | Cost: 0.6657475 | Acc train: 0.9200000 | Acc validation: 0.9600000 \n",
            "Iter:    29 | Cost: 0.6649032 | Acc train: 0.8933333 | Acc validation: 0.8400000 \n",
            "Iter:    30 | Cost: 0.6461630 | Acc train: 0.9333333 | Acc validation: 0.9600000 \n",
            "Iter:    31 | Cost: 0.6375842 | Acc train: 0.9333333 | Acc validation: 0.9600000 \n",
            "Iter:    32 | Cost: 0.6378861 | Acc train: 0.8933333 | Acc validation: 0.8400000 \n",
            "Iter:    33 | Cost: 0.6569402 | Acc train: 0.7600000 | Acc validation: 0.7600000 \n",
            "Iter:    34 | Cost: 0.6661625 | Acc train: 0.6266667 | Acc validation: 0.6800000 \n",
            "Iter:    35 | Cost: 0.6364352 | Acc train: 0.7866667 | Acc validation: 0.8000000 \n",
            "Iter:    36 | Cost: 0.6282800 | Acc train: 0.7866667 | Acc validation: 0.8000000 \n",
            "Iter:    37 | Cost: 0.6079254 | Acc train: 0.8133333 | Acc validation: 0.8000000 \n",
            "Iter:    38 | Cost: 0.6142264 | Acc train: 0.7733333 | Acc validation: 0.8000000 \n",
            "Iter:    39 | Cost: 0.5787372 | Acc train: 0.8400000 | Acc validation: 0.8000000 \n",
            "Iter:    40 | Cost: 0.5306319 | Acc train: 0.9066667 | Acc validation: 0.9600000 \n",
            "Iter:    41 | Cost: 0.5054638 | Acc train: 0.9600000 | Acc validation: 1.0000000 \n",
            "Iter:    42 | Cost: 0.4936629 | Acc train: 0.9333333 | Acc validation: 0.9600000 \n",
            "Iter:    43 | Cost: 0.4736051 | Acc train: 0.9600000 | Acc validation: 1.0000000 \n",
            "Iter:    44 | Cost: 0.4634116 | Acc train: 0.9466667 | Acc validation: 0.9600000 \n",
            "Iter:    45 | Cost: 0.4428351 | Acc train: 0.9600000 | Acc validation: 1.0000000 \n",
            "Iter:    46 | Cost: 0.4250885 | Acc train: 0.9600000 | Acc validation: 1.0000000 \n",
            "Iter:    47 | Cost: 0.4109724 | Acc train: 0.9733333 | Acc validation: 1.0000000 \n",
            "Iter:    48 | Cost: 0.4012014 | Acc train: 0.9733333 | Acc validation: 1.0000000 \n",
            "Iter:    49 | Cost: 0.3791405 | Acc train: 0.9866667 | Acc validation: 1.0000000 \n",
            "Iter:    50 | Cost: 0.3557057 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
            "Iter:    51 | Cost: 0.3482645 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
            "Iter:    52 | Cost: 0.3474582 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
            "Iter:    53 | Cost: 0.3548593 | Acc train: 0.9600000 | Acc validation: 0.9200000 \n",
            "Iter:    54 | Cost: 0.3473231 | Acc train: 0.9600000 | Acc validation: 0.9200000 \n",
            "Iter:    55 | Cost: 0.3253799 | Acc train: 0.9600000 | Acc validation: 0.9200000 \n",
            "Iter:    56 | Cost: 0.2898395 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
            "Iter:    57 | Cost: 0.2764701 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n"
          ]
        }
      ],
      "source": [
        "opt = NesterovMomentumOptimizer(0.01)\n",
        "batch_size = 5\n",
        "\n",
        "# train the variational classifier\n",
        "weights = weights_init\n",
        "bias = bias_init\n",
        "for it in range(57):\n",
        "\n",
        "    # Update the weights by one optimizer step\n",
        "    batch_index = np.random.randint(0, num_train, (batch_size,))\n",
        "    feats_train_batch = feats_train[batch_index]\n",
        "    Y_train_batch = Y_train[batch_index]\n",
        "    weights, bias, _, _ = opt.step(cost, weights, bias, feats_train_batch, Y_train_batch)\n",
        "\n",
        "    # Compute predictions on train and validation set\n",
        "    predictions_train = [np.sign(variational_classifier(weights, bias, f)) for f in feats_train]\n",
        "    predictions_val = [np.sign(variational_classifier(weights, bias, f)) for f in feats_val]\n",
        "\n",
        "    # Compute accuracy on train and validation set\n",
        "    acc_train = accuracy(Y_train, predictions_train)\n",
        "    acc_val = accuracy(Y_val, predictions_val)\n",
        "\n",
        "    print(\n",
        "        \"Iter: {:5d} | Cost: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} \"\n",
        "        \"\".format(it + 1, cost(weights, bias, features, Y), acc_train, acc_val)\n",
        "    )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fqozdRWMyqM4"
      },
      "source": [
        "We can plot the continuous output of the variational classifier for the\n",
        "first two dimensions of the Iris data set.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 124,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "Aju2qpgByqM4",
        "outputId": "b8811b7a-9def-4545-b6a3-1c2806695d4f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgoAAAGdCAYAAABzSlszAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADJA0lEQVR4nOydd3hT5d+H7ySdjLa00EHZFGSXDS2ooCCzLBUEkSECoqjIT1CWgCI4EdziABwskSEIovIKyN4VZI8OSnftArqSvH+kaZs2STNOkpP03NfVC3pyznmedOWT7/rI1Gq1GgkJCQkJCQkJPcgdvQEJCQkJCQkJ8SIJBQkJCQkJCQmDSEJBQkJCQkJCwiCSUJCQkJCQkJAwiCQUJCQkJCQkJAwiCQUJCQkJCQkJg0hCQUJCQkJCQsIgklCQkJCQkJCQMIibozdgCiqVitu3b1OzZk1kMpmjtyMhISEhIWLUajU5OTnUrVsXudwx74ezsrJo3rkPR3/fROPGjR2yB6GQOcNkxlu3blG/fn1Hb0NCQkJCwomIj4+nXr16Dlm7bqv7Sbx0iIAGrUmLOeeQPQiFU0QUatasCcC3EQOo5ubu4N0Ij0dGEr7NnFtxapHnpVO9cUNHb8MobuTgFSou4enpXohbnbqO3kYJ7l5yFLXqOHobOig8vJDVrOXobVTEqxoyrxqO3oVRlB6a/cncPR28E9PJyc1l1LinAVj7w3qqV69u+rU5ObS+L6zktcPexMfHk3zlKM16juL64Z85efIknTt3dshehMAphII23VDNzd0lhYKnwo3q7h6O3oYgKJTuVPcU73NxJwfwwMtLPH8wPd0LAU/cq3k5eisAuHspAFBUr+bgnZSi8PRCVtPf0duoiLfmxUvm5ZgXJFNQempFgjh+vkzlyq1kQkJC+OzLr80SCWVxVKq64wNR1KrXEv96LbhzXzceGvQYWUk3nTZ1LhUzSlQ5vOo1cPQWKuAeFOroLeig8A909BZKUHiK9AVOEgk2ITMzi592/kbLli3NjiSIgbNnz5IR/y/12z0EQEjLntzLSmXnzp0O3pnlSEJBQkKiBG00QWyIMpqAJBKEJiPjPx4ZMpwff/gBZOL8WTSGWq3mwf6PEtSsK541NGkyNw8vQts8yMixT1NUVOTgHVqGJBREQtbl647egoQD8HQvlKIJRhBzykHMIkGLM4mEtLR0+gweSr169Vjz/TqnDNP//vvv3PnvNnVb369zPLBpJ9QqFc0jhztoZ9bhFDUKrk5+QAie6YmO3obL406OKNMOjkYNKBXuKLw9yAcUMnHUAck9PCkEZCqRvWB4eYNSjaxQ6eidGETpUQ2ZSg75BY7eisns3vc33bt3540ly0CtpiA/X/+JMpDLFSgUClGJCaVSyfBR4wht/QBuHt46j8kVbjRo34eYk7+Sm5tLjRriLn4tjyQUJARDkZdG9aaNHL0Np0FTxOhYihQeZAQ0pLBGLZDLkclFFO6VyUAuBzG9HsvkcBfN3u4ZeCFzNDI5kAWI50XUGEqlEpVaTbcuXejWpSsZqckmXefh5YV/QB3c3MUhbJv3eBRVUQFBzbrqfbxWvZYkXjpCi4jB3Dq3z657sxZJKEhIOBBHph3UyEiu2wp3n1rU9ffF3c0NuUIkQkEmL/5HJPvRIpeX7E2MqLV7E9E7bWMUFRURExtHzZo1CQwKNu0itZqCwkLS0lJJun2L0AYNkTn4e3L37l3i//k/GnZ4BLlC/8uqTCajQfu+XNr3PYmJiYSEhNh5l5YjCQWJKoGmLVKiLIXunuDhRUhALap5eyIz8AfO7sjFKhIUJXsTI2pt8Z8TiYQbN2OoUaMGDRo2xJwIiJe3N+5ubsTFxVFYWIiHh2Pbne+LiMLDuyb+DVobPa9mnQb4BofR/v4okq+dtNPurEe8P/USEgIjpvoEcRQxav4wyxXi+zMgSpEgYpxNJADcTkzCy8vbbJGgRaYVbQ6eLZySksLtCwdp0OERkyIbDdr3ITUmmgsXLthhd8IgkrcQEhISjkRs0QRRoRUJYtxbWZxEJKhUKtQyOXVDQ4tfWJ1j34Zo13MwPkGN8AlsZNL5XjUDCGzSkR59h/NfwmXbbk4gRP6TLyHheoihiLEEEb64iC6aAKIWCWqZQpTfR32oVCquXr9BSnIycrm4uhYs4cqVK6TcOEOD8L5mXRfa5kFyUmPZt2+f2WseOHCAqKgo6tati0wmY9u2bWbfw1zE+9MvISEQYmyLdHzaoRSZWAoYBei6iImNRV7Nh7PR/wi0J5F8bQyg1jOUqEnTMFauXOmA3RhHrVJz/cZNZECdwCBHb0cQuj88lDqNw/H2Nc8Xxd2rOiEtezL40TGoVCqzrr1z5w7h4eF8+umnZl1nDZJQkBAEqTXS+XDzFNGvvxjfsVuQclj19Tf07vMIvgGByD28yczMrPSa3n0eYcb/XjF7e4bqEo4dPcLkyZPNvp+tiYmPR6VS0aRpU4dZPwvJoUOHyEq6TmibXhZdH3xfNwru5bJx40azrhswYABLlixh+HD7DW9y/u+WhIQTIY4ixlJkAvzBViqV7Pv7IOt/+pl9fx9EqbRs8IErpBzu3r1Lv0f6MufVWYJuQ61W64z/NVa8WKdOHapVE4+hF4AKGUFBQTRpGoZcjN9nM1Gr1fQf9gQhLXrg4W3ZhE6Fmwf12z3ExMnPkZ2dXeEj39DAKQcgCQUJl0Zqi9SPUJ4OW37ZQZPWnXl40FDGTprCw4OG0qR1Z7b8ssP0m5j5YqxSqXh3+QqatQnHy682DZu34q133tN7rlKpZNKzz9OkZVuq+QfSIrwjKz/9TOecfQf+ptv9vahRO5haIfXp+VBfYuMTQC4nOvofHurbDx//OvgGBNK5WyQnT50yuLcZL77Aa7Nn0b1bN5Oey8RJk9l/4G8++vhT5B7eyD28iYmJZd/+A8g9vNn92x46d4vEq4YvBw8d5vr1Gwx99HFCQuvh41eLbt278+efe3XuWT71oHBz5+tvvmHEo49Ro6YP97VoyS87zPj+WIMaYmLjyPzvP7y8vFGIJc1lJSdPnuTOfynk+YdzPfmOxR9Z1cIoVMEzzzyDr6+vzseyZcsc/TRLEEmps0R+QAhZl6/je19TR2/F5RBLfYKoihgBhW+AVddv+WUHI5+aiFo9GNgItAHOk5C4lJFPTWTT96sZMSTKpHuZE02Y8/oivl69huXvLKNnZASJSclcunxF77kqlYp6oXXZ9MNaAgL8OXz0GFOnv0RIcDAjHx1BUVERw0eN4ZmJ41m39lsKCgo5fup0SZHd2PET6dA+nM8+/giFQsHZ6GjcBbS6X7H8fa5cvUrr1q15Y+ECQBMRiImN1TzXeQt4751lNGncmFq1/IiPv8WA/gNY8uabeHp68v33PzB02DAuXviXBg0M/5y/+eYS3n57Ge++8zaffPopTz01jps3ruPvb1sfjdj4eO7cuUPdUPFE0YQgPz8fD+/qtGreyOp7RV8MYMCAAXz99dc6xz09HTsboiySUJCQsCNiSDsIEU1QKpW8PPv1YpGwjdLgZHfU6m3IZMOY+epChg4aaPxdpJkFjDk5OXz06ed8vPx9xo99EoCmTZrQMzJC7/nu7u4sXjCv5PPGjRpx5Nhxfvp5KyMfHUF2djZZWVkMHtCfpk2agFxBy1atSqIccfHxvDLzZVq0uA+AZs3CTN6rKfj6+uLh4UG1at4EB1ecTLh44QL69nm45PNaAXVo16FjyedvvLGYbdu3s2PHDp5//nmD64wfN47RTzwBwFtLlvDxx59w/PgJ+vfvJ+Cz0SX+VgI5OTk0a94cNwHFlSvi7u6Oj4+Po7dhECn1ICFhB0QXTbDSIfLvw0e4dTsOmEvFPyNy1Oo5xCfE8vfhI4ZvYkF9xMVLl8nPz+fh3g+afM2nX6yic+QDBDZoTM06IXz17Rri4uMB8Pf3Z8LYJ+k/ZDhDHh3Jyk8+JTG51Gvg5ZdeZPKz0+jbfyBvv/se16/fMHvP1tC5U6koUMsU5ObmMmvWbFq3aYt/QG18fP24ePEicXHxRu/Ttl3bkv9Xr14dHx8fUlJTbLZvFTK8vLwIa9YMd3cPm60jYR/M/k21pofz0KFDuLm50b59e3OXlZAwG7G1RYolmiCEjXRikvbFtI2BM9qUO08/5hYwent7V35SGTb8tJlZc+fz9Pin2PPLNs4cPciEp8ZSUFAq3L5d9TmH//qTiIjubNr8M/e1bsfRY8cAWPT6fM6fPc3AAf35a99+Wod3YOu27WbtwRqqV68OlBYvznr1VbZt386SJW+yf99fnD51krZt21BQaNwl0r2ccZJMJjO7Lc9UEm4nkp+XR0DtOg4freyK5ObmcvbsWc6ePQvAzZs3OXv2LHFxcTZb02yhYGkPZ2ZmJuPGjePhhx+u/GQJp0Jqjax6hARr++DPGzjjfLnzymFht0WzsKZ4e3uz96/9Jp1/6MhRIrt347mpk+nQPpywpk25cfNmhfM6dOzInNmzOHRgH21at2LdhtKWtebNm/HySy+yZ9dORgwbypq131u0d0N4eHgY7RQp2+Fw+PBhxo8bx/Bhw2jbti3BwcHExMQKuh9riI2LJzMzUzzmYi7IyZMn6dChAx06dABg5syZdOjQgddff91ma5pdozBgwAAGDBhg9kLPPvssY8aMQaFQ2GWSlISEWBBL2kGoaALA/ZER1KvbgITEpajV29B9z6FCJltGvboNuV9f7YAVpk9eXl7MnjmDV+cvwMPDnR4R3UlNS+PfC5eYNGFchfObhTXl+3Ub2PPHnzRu1JDv123gxKnTNG7YEICbMTGs+nYtQwYPom5oXS5fucrVa9d5auyT3Lt3j1mvzeGxESNo3KghtxISOHHqFCOGDTO4v6SkJJKSkrl2/ToA586fp2aNmjRoUN9g4WDDhg05fvwEMTGx1KhRXee88m2QYWHN2LptK4MHD0Imk/H6wkU2iwyYhRpi4uK4c+eOlG6wMb169UKttq/BhV1qFFavXs2NGzdYuHChSefn5+dX6CmVkDAHsbVFOjrtIFQ7pBaFQsGH774B7EQmGwYcAXKAI8Wf72T5O4sNFjJaMzNhwZxXmfniCyx8cymtOnThiacmkpKaqvfcqZOeZsSQKJ4YN5HuDz5MekYG06Y8U/J4Ne9qXL5yhcdGj+G+1u2Y+tzzPPfsVKZOfgaFQkFGegbjn57Efa3bMWrMWPr3e4TFxd0J+vhi1dd07NqdKc8+B8CDD/WlY9fu/LLzV4PXvPLyDBQKBa3DOxBYt37FeoMysxI+eP89avnVouf9DzB02HD6PdKXjsXvLB2JUq1GLpfTrFlzSSS4IDK1FdJEJpOxdetWhhlR2FevXqVnz578/fffNG/enEWLFrFt27aS/Io+Fi1axOLFiysc33D/EKq5cPWsZ3qiU7ZHijH1IJb6BG00QQxCoXw0IV/mTkL1+jRqUA8vD8v+uG/5ZQcvz369uLBRQ/3Qhix/Z7H+1kixWUiL1DraWdwg1Wo1ySmp1KkTKMjwLnPIy8sjNiaGwJBQPMq1EmZnZ9OgbhBZWVk26SY4ePAgfQYMoesT1of7o3d+wqfvLWLs2LEC7Mw22LQ9UqlUMmbMGBYvXkzz5s1Nvm7OnDnMnDmz5PPs7Gzq169viy1KSNgcMYgEWzFiSBRDBw3k78NHSExKJiQ4iPsjI4y2RIpKJIgZJxAJN27GUFBQQEDt2iikJjqXxaZCIScnh5MnT3LmzBmmT58OFFuMqtW4ubnx+++/89BDD1W4ztPTU1TDJiScC7GlHcSAULUJeu+tUNDr/p6VnyiA6ZNgiNg62hncINVqNddvxlBYWEhYs2YoxGJTLmETbPrd9fHx4dy5czrHPvvsM/7v//6PzZs307hxY1suL2EHFHlpjt6CXsSSdnDlaIJZiPAFWYx7cgaRAJBXUAhqNWFhYZJIqAKY/R3Ozc3l2rVrJZ9rezj9/f1p0KABc+bMISEhge+++w65XE6bNrp91oGBgXh5eVU4LuG8iK0+QUIXW0YTzEFU0QSxigSRo1KpyMrJxdfXlyZNhZ1SKSFezBYKJ0+epHfv3iWfa2sJxo8fz5o1a0hMTLTp4AcJCWdADC2RUjRBD2IRK+VwhuJFtUrF9Rs3UavV+Pr6Ono7EnbEbKFQWQ/nmjVrjF6/aNEiFi1aZO6yEhImIZZuB3B8ESOIIJogpi4HkdYlOIVIKK5JUKlUNA0LA8S7VwnhEddvjISEhCCIJpqASESCFkkkWERWdg5FRUU0aRqGXEzfTwm7IK7fmiqO1mpawrkRQxEjiCeaIApEWpcAiF4k5BcU4uPrS7Pm9xl3ApVwWUT6myPhDIit40Fqi9RQlaMJMbGxyKv5cDb6n9KDIn0HLGSHQ5OmYaxcubLkc4WbO9u2GzaviomJQeHmbnTwHUBs/C1iYmIAGTI9e42JicHdTVHpfVwRmVxB9ToNrP5QuIt/FIAkFCSsQmwdD46uTxBDESOII5ogipSDnesSVn39Db37PIJvQCByD28yMzP1nmfrDoeEW/EM6N/fqnvEJ9wmJzubRsVt7E8/PZFHRwzXOad+/frE30qQuthcHEkoSEgIjCPTDo6KJqjVak6cOq0pdBZbiN+O+7l79y79HunLnFdnGTzHHnUJwcHBVg2tS0v/j8z//iMszLjBk0KhIDg4GDc3cc1S+C+vyNFbcClE9hstISFhLY6IJvywYRPde/flx40/AbZNOahUKt5dvoJmbcLx8qtNw+ateOud9yqeKFegVCqZNOVZmjRvQTWfWrRo3Y6VH3+ic9q+/QfoFtmTGn4B1KoTTM8HexMbq7Fujo7+h4f69sPHvw6+AYF07hbJyVOnDO5txosv8NrsWXTv1k3v4+VFwqqvvqJe/QYVHCCHDR/BpGc05lXXr19n2PARhNQNxcfXj27du/Pnn3uNfo3Kpx6OHz9Op86dqVa9Bl27deNMuVSBUqnkmcmTaRrWjOo1atKzZw9+/+OPEg+FNxYv5vvvvuOXX37B3U2Bu5uC/fv26U09HNi/n4ju3alezZv69UKZO2cORUWlL9wPP/QQM2a8xGuvvkpgndrUC63LG3q8fSwh414RGfeKUIi87sPZEJcMlJCwEDG0RTq6iNFR0YSioiIWL/0AgMVLP2D0E6Nws+FbkDmvL+Lr1WtY/s4yekZGkJiUzKXLV3RPKo4iqIB6oaFsWv8jAf4BHD5yhKnPTSckOJiRjz9GUVERwx8byTOTJrLu++8oKCjg+ImTJfn4seMn0qF9OJ99/BEKhYKz0dG4W2hMpy+S8Phjj/HSSzP46699PPywZpx9RkYGe/bsYeeOHYBmyN2AAf1Z8uYbeHp68v33PzB02DAuXviXBg0q/5nPzc1lyNBh9OnzMN+tXcvNmzG8XMZLBzTiq15oPT7//HM8Pb2IvxXPtGefpV69ejz++Ehm/u9/XLp0kezsbL7+5lsA/P39uX37ts59EhISiIoazLjx41m9Zg2XL1/i2alT8fLy4vUy7sHff/cdM2a8zKHDRzh69AiTnn6ayMhI+vTta/4XtpiMexoxopBLIkFoJKEgIeFCOCKasP6nn7kZex1YxY2YKWz4aTNjRz9hk7VycnL46NPP+Xj5+4wf+yQATZs0oWdkRMWT5XLc5XIdW+jGjRtx5Ngxftr8MyMff4zs7GyysrIYPHAgTZs2AaBlyxYl58fFx/PKzJdp0eI+AJo1s3IaYbl3urVq1aJ///6s37C+RChs/vlnateuTe/evQAIDw8nPDy85Jo33ljMtu3b2bFjB88//3ylS65bvx6VSsXXX32Fl5cXrVu35lbCLZ5/fnrJOe7u7jw/fToJCQmEhTXj/gce4OjRo2z+6Scef3wkNWrUwMvbm/z8fIKDgw2u9cXnn1O/fn0++uhjZDIZLVq04PbtRObOeY35CxYgLxZwbdu2Y8HrGufFZs2a8dmnmtH+lgoFSSTYFin1IGERYut4cDSOLmJ0dDRBJhsCTEYuj2LRknd1Qs1CcvHSZfLz83m494PGT5SV/mn79PMv6NwtksC69alZqzZfff0tcfHxgOZd8YRxT9F/UBRDhj3Kyo8/ITExseTal196kcnPTqNv/4G8/e57XL9+w6J9G+twGDNmNFu2bCU/Px+A9evWM2rkyJIX1dzcXGbNmk3rNm3xD6iNj68fFy9eJC4u3qS1L128RLu2bfHy8io5FtG9u845aekZfPjhhzz99NM0bdoEP18fvv7qK5PXKFnr0kW6de+u0yERGRlJbm4ut27dKjnWtl1bnetCQoJJSU0xay0tWfmSSLA1klCQsBixdDyIpS3S0bMTHBlNUKs1YWWVaiE3bl5jw0+bbbKet7e38RPKdRNs2LiJWa/O4emJ49nz6w7OnDjGhPHjKCgoFXbffr2Kwwf2ERHRnU0/bea+1u04euwYAIten8/5s6cZOKA/f+3bT+vwDmzdZrjtUB+VtUFGDR6MWq3m1127iI+P5++DBxkzZnTJ47Nmz2bb9u0sWfIm+/f9xelTJ2nbtg0FhQVm7cMQKmTs2rWLlStXMumZyeza/RsnT51m/IQJgq1RHnd33fSNTCarUKdhCqriKcGSSLAtklCQcAkcWZ8gRROGAB2Lj3ayaVShWVhTvL292fvX/ooP6imgPHTkCJER3Xnu2al06NCesLCm3LhRMSrQoUN75rw6i0MH9tGmdSvWbdhY8ljz5s14+aUX2bNrJyOGDWXN2u9N3q8pbZBeXl4MHz6MdevWs2HDRu677z46duxY8vjhw4cZP24cw4cNo23btgQHBxMTE2vyHlq0bME/586Rl5dXckwrhNIz/iM9LY0TJ08SERHJtGnT6NChA2FhYdwoFz3x8PBAqVQaX6tFS44dPaoz5v/w4cPUrFmTevXqmbxnU1CpNGvIpcJFmyMJBQkJAZCiCaXYMqrg5eXF7JkzeHX+Ar77cR3Xb9zg6PHjfLPmO80J5Vohm4WFcfLUafb8/gdXrlxlwcLFnDhZ2rVw82YMc+Yt4MjRo8TGxvL7H39y9dp1WrZowb1795j+0gz27T9AbGwshw4f5sSpUyX1CvpISkri7Nlorl3XTFg9d/48Z6OjycjIMPq8xowew65du1i9Zg1jRo/WeSwsrBlbt23l7NmzREdH8+TYp8x69z1m9GhkMhlTpk7lwoUL7Nq1m+XLPwQgPT2datWrExbWjFOnTvL7nj1cuXKFha+/zsmTJ3Tu06hhI86dO8fly5dJS0ujsLCiQH522jTi4+N56aUXuXTpEr/8sp03Fi9ixoyXS1IpQqAsFgmS5YR9kISChFMjlrSDo3B8NGEA0BrIL/PRBrl8gM2iCgvmvMrMF19g4ZtLadWhC088NZGUtDS98xKmTn6GEcOG8sSTT9G95wOkZ2QwbeqUkserVfPm8uXLPDZqNPe1bsfU557nuWenMnXyMygUCjLSMxj/9CTua92OUWPG0r/fIzrFkeX5YtXXdOzanSnPPgdAr94P0alzF34p7mAwxEMP9cbf35/Lly8zulwh6Afvv0ctv1r0vP8Bhg4bTr9H+tKxQweTv141atRg+7atnD9/nk6du7Dg9QXMnj0bgPoNGuDtXY0pU6YwbPhwxowZTY/ICNIz0nn22Wk695n0zDM0b96c7t26EhIcxOFDhyqsFRoayo4dOzlx/ASdOnbg+eeeY+LEp5k7b57J+zWGUqXWiAQZkkiwIzK1MStIkZCdnY2vry8b7h9CNQtbk5wFz/REfO9r6uhtVIoiL00UNQqObosUQ0ukpdGEfJk7CdXr06hBPbw8DA/V0ce+vw/y8KChlZ73f7/9Sq8H7rdofyYjMldIsRs9qZCRkZ5OtWrV8aqs5kNElI8i5OflERsbQ/WAENw8dIdL5WRn06ZxXbKysvDx8RF8LwcPHqTvoOH0ev5Lq+917IcFfLR0DmPHjhVgZ7ZBao+UMBup40EcWCMSrCWiaxc2fLeaAj3hZy2enp5EdOtq241IIsEsEpNT8PXxwT+gtqO3YhZSqsGxSEJBwiLEEE1wNI4uYnQknt7ePD5imEj8HMQhEkoQqUi4dTuR/zIy8PP1c/RWzEISCY5HEgoSTouj0w7guCJGR0YTtDhcJIjMOlpIN0ihuZVwm//++4+wZs2t8oCwN5JIEAeSUJCQsICqHE0QhTOko9cvh5hFglINSpWKZs2al3g3OAOSSBAP4pHjEhJORpWMJojhHbxY6xJESEpqGmq1mvr1G0giQcJipIiChFNSVdsiHdUOWRaHRxNAfCJBhNGE2Phb5GTn4Ovnh1wM3zMTcCaBIJcrqB4QYPV9FO7i7+QTx2+bhNMgpo4HR9UnODrtIEUTxIGYRcKthNvkZGfTrHkz3N3Na311FM4kEqoaIvjNl3A2pI4Hx6QdHBpNKBYJDo0miCjlIGaRUFCkJDc3l7AwSSRICIPjf+MkdMgPCCHr8nVHb0PUODLtUGWjCUgiQYuYRcKde3m4ubnR/L4WTlOTIIkE8eP43zoJCQtwZFtkVY0mOBwT9hETE4vcw5uzZ6NtuxcRioTUtHSuXb2qd2y2u5uC7du32X9TlSCJBOdAJH8BJCQkKqPKRxNEgCVtkEuXLqNnz/upUdP0iYhNmoaxcuVKk9fIyPiPhIQEmjRtipueMffxtxLo33+AyfezB5JIcB6krgcJCRNxlK+Do6MJlYkEpVLJ34cOk5iUREhwMPf3iEShEGjPYkw5mElBQQGPPfYo3bt359vVqwXbj1KpRCaTUVRURFx8PI2bNKF69Rp6zw0ODhZsXSGQRIJz4fjfPgmnQQwdD2KYxugIHBJNMOHFecu2X2jWojUP9R/EkxMm8VD/QTRr0Zot234RYH39IkGlUvHu+x/QrGVrvGr40rBpM95a9o7eWyiVSiZNeZYmzVtQzacWLVq3Y+XHn+ics2//AbpF9qSGXwC16gTT88HexMbGAhAd/Q8P9e2Hj38d/PwD6NKtGydPnjTraSxatJAZM2bQpm0bk85/6KGHiY2NZeb/XkHh5o6iOEKwZu1a/ANq88uOHbRp2w7vatWJjYnlTPQ/zJo1i2ZhYQT41+Kh3r05ffq0zj3Lph5iYmJwd1OwdesW+jz8MD41a9CxYweOHDli1vOyFMn90fmQhIKEWVTVjgdHFTE6em6CsWjClm2/8PiTT9E24TZHgBzgCND2diKPP/mUQGKh4p+oOfMW8M57HzB/zhz+jT7Dj9+tIShIv5BSqVTUCw1l0/of+Tf6DAvmzWHegoVs+mkzoLHLHv7YSB544H6iT53g8IF9TJ40CVlxemHs+ImEhtbj2JHDnDh+jNmzZ+Nu4773zZt/ol69eixetIiEW/Ek3Ioveezu3bu89+57rPryC44cPkRaRgbZ2dmMGz+effsPcPDQYcKahTEkajA5OcaLfl9fsICZM2dy8tRpmjdrxlNjn7SJLbgWHYtoCadCSj1ISJiIoyYxijGaoFQqeWXWbAar1Wyj9B1Hd2CbWs0wmYxZs19laNQgy9IQBgRKTk4OH33yKR+v/JDx4zS2vE2bNqFnjx56z3d3d2fxwgUlnzdu3Igjx47x0+afGfn4Y2RnZ5OVlcXggQNp2rQJAC1btig5Py4+nv/9byYtWrYEoFmzZuY/FzPx9/dHoVBQs2aNCimDwsJCPvnkYxo3asyNmBgaN2iAXy1/nXO++OJLagf4c2D/fgYNHmxwnZdnzmTgoEEAvL5wEeHt2nLt2jVatGhh8BpLkVINzo0UUZBwGqraNEaHRRNMmJnw96HDxCTcZi4V/4jIgTlqNTdvJfD3ocMWrG+4LuHipUvk5+fzcO/eJt/u08+/oHO3SALr1qdmrdp89fW3xMVr3qX7+/szYdxT9B8UxZBhj7Ly409ITEwsufblGS8xZeqzPPJIP955512uXzfcujztuefw8fUr+bAFHh4eNG0axo2YGBo0bIhfLX+Sk5OZOnUKLVvcR4B/Lfxr+ZGbm1vyHA3Rtm27kv+HhIQAkJqSIvieJZHg/EhCQcKpcER9gqOKGMFxnQ6VFTAmJiUBYCjr3qbceSZTSfGit5e3WbfbsHETs16dw9MTx7Pn1x2cOXGMCePHUVBQmkr69utVHD6wj4iI7mz6aTP3tW7H0WPHUMsULFy4kHP/RDNw4AD+76+/aNO2HVu3bdO71uJFizh96mTJhy3w9vbGu3p1moaF4edXC4CnJ04gOjqa5cs/5MDfBzl56jQBAQEUFBQYvVfZFIo21aJSqQTdryQSXANJKEhIiBCHGT+Z2F0QUhwSP2/g8fPlzhNqD82aheHt7c3ev/4y6VaHjhwhMqI7zz07lQ4d2hMW1pQbN25UOK9Dh/bMeXUWhw7so03rVqzb8FPJY82bN2fGjBns+W03w4cPZ82atXrXCgwMJCwsrOTDGjw8PFAqdV+07969i0qlQiaT63Q3HD58mOnTpzNg4EBat26Np6cnaWmOLzyWRILrIAkFCZNwdMeDo9IOjihiFHMBo5b7e0TSKLQuS2Uyyr8HVQHLZDIa1wvl/h6Rpi8sV1QqVLy8vJj9yv94dc48vvv+R65fv8HRY8f4ZvUavec3Cwvj5KnT7Pn9D65cucqChYs5cfJUyeM3b8YwZ94Cjhw9SmxsLL//8SdXr12nRYsW3MvL44UXX2Tfvv3ExsZy6NAhTp48SUszc/hxcXGcPXuW+Lh4lEolZ8+e5ezZs+Tm5hq8pmHDhhz4+28SEhJIS0vjv8xM0tLSS975lyWsWTN+/OEHLl68yLFjxxj31FN4e5sXeREaSSS4FlIxo4TJOLrjwVFtkY5IOzgqmmDqYCWFQsH7773L408+xTCZjDlqNW3QRBKWyWTsBH569x3TCxnNGKq0YN4c3NzcWPjGG9y+nUhISDBTJ0/We+7Uyc9w9mw0Tzz5FDKZjCdGjWTa1Cn8tud3AKpV8+by5cs89sMPpKdnEBISwnPTnmXq1CkUFRWRnp7BhIkTSU5Opnbt2gwfPoxFixaavFeAhYsW8d1335d83qlzFwD2/vknvXo9qPeaxYsWMu2552jW/D7y8/M5deoUtevU0SsUVq36imnTnqVrl87Ur1+fN5cs4dXZs83ao1BIAsE1kanVarWjN1EZ2dnZ+Pr6suH+IVTTM3XM1fBMT8T3vqaO3oYOirw0hwoFR8xP0EYT7CkUtNEEewiFfJk7CdXr06hBPby8vADzJzBu2fYLr8yaTUzC7ZJjjeuF8t677zBi2BDTbiKSoUpi9XC4l19AYUEhNWrWdPRWjGJvkZCfl0dsbAzVA0Jw89D1tcjJzqZN47pkZWXh4+Mj+NoHDx6kX9RjDJi/0ep77f/sJT5c/Apjx44VYGe2QYooSEgYocpEE7BsTPOIYUMYGjXI+smMkkioQHpGBkVFSuoEBuHp6eXo7RhFiiS4NpJQkBA9VWUao8NqE2TWvUgrFAp6PXC/ZReLwMdBjCIhLT2DW7du0aSJuCKL+qiqIkGmkOETUM3q+yjcxV8qKAkFCQk9OKol0u7RhOIXR4eYPokk5QCISiSkpqUXGzyFUaOGfu8GsVBVRUJVw+zf0AMHDhAVFUXdunWRyWRsM9BTrGXLli307duXOnXq4OPjQ0REBHv27LF0vxIOwNH1Ca6OUqXiyNUbbDpwkgNn/q3QFmdrqrJIsMQN0paokCGTy2kqiQQJEWF2ROHOnTuEh4fz9NNPM2LEiErPP3DgAH379mXp0qX4+fmxevVqoqKiOHbsGB06dLBo0xJVB0e0RdqzJXLH8Wjmr9lKXEZmybGGdfx5+8UJDHuwm03XlpcrALM7YhAJIiI1LZ1q1arh7x/g6K0YRRIIVQ+zhcKAAQMYMMB0X/MVK1bofL506VK2b9/Ojh07JKEgYRKOqE+wR9phx/Foxi9fzWBgI5S0Fy5NzWDMguWse3OmzcSCwtOLQnDMi7VUl1CBlNQ0EhMTadrUukFNtkYSCVUTu/+VUKlU5OTk4O/vX/nJEhJ2xl7RBKVKxfw1WxkMbENjplSj+N9twGBgzsdrbZqGkFX3tdm9DSKClIPYREJ6ega3b9+maVgY1apXd/R2DCKJhKqL3X9b33//fXJzcxk5cqTBc/Lz88nOztb5AEi9UnH0qoTr4qhpjPaIJhy5eJ24jEzDpkpATEo6h/65KPjaCke32kkiQYec3FyaNG1KtWqSSJAQJ3b9jV23bh2LFy9m06ZNBAYaru5etmwZvr6+JR/169e34y4lyuLo0c2u2haZlKkRv5WaKqVn2mR9WU0HRPRMGNFsS8QmEu7cuUORUk2Dho2oUUO8w5QkkSBht9/aDRs28Mwzz7Bp0yb69Olj9Nw5c+aQlZVV8hFfxi415dI1W29VohxVpePBnkWMwX6aaXGVmioF+Am6rsLTy3EiwQ7ExMQi9/Dm7Nlo/SeIRSTk3uHqtevk3rljszXc3RRs374NgJiYGNzdFJw9e9bg+fv37cPdTUFmZmbJMUtEwv79+/Byd9O5j4RzYxehsH79eiZOnMj69esZNGhQped7enri4+Oj8wGQJ0UWJGyMvWYnRLRsSsMAP5aCflMloFFgAD3atRRsTYelHMRSl+AgkbB06TJ69ryfGjV98A+ozb2797h24wahoaE2GS+sj/r16xN/K4E2bQzFsCpiikjo+/BDvDJzps6xiIhIYuJv4evrgBoYCZtg9m9ubm5uifsZwM2bNzl79ixxcXGAJhowbty4kvPXrVvHuHHj+OCDD+jWrRtJSUkkJSWRlZVl8aalqILrY+9pjPZ2ifSq5s7SZx5lJzAMOALkFP87DNgJLHthPAqFsC+utoomqNVqTpw8hUHrGEeLBAdSUFDAY489yrNTpwIQEx9PUHAwAbXr2G0PCoWC4OBg3NxMa3SzJt3g4eFBcHCwXgMrCefE7N/ekydP0qFDh5LWxpkzZ9KhQwdef/11ABITE0tEA8CqVasoKiri+eefJyQkpOTjpZdesmjDeQ0bWnSdhERl2HsS44hBj7DuzZn8U8efSMAHiATOBQYI3hpp65TDD+s30O2B3vy4oZxJjg1SDiqVinff/4BmLVvjVcOXhk2b8dayd/SeW6SCZyZPoWmz5lSvUZOWrVrz0Ucf6Zyzb99+unePoKaPL/4Btbn//geIjY0FIDo6mocf7oOvXy38avnTpWtXTp48adZ+Fy1ayIwZM2jVqhUAYWFhBAYGGTx//rx5REZEVDjesWMHlrz5JgAnTpygf79HCA4KJMC/Fg/17s3p06cN3lNf6mH3rl20atmCmjWq0+fhh4mJjQFKRUJ6RjpPjX2SJg0bUMunJp3at2fjhg0l1z/z9NP8feAAn3z8EV7ubni5uxETE6M39bB1yxY6hLfDp3o1moc1ZcWHy3X21zysKe+8vYwpzzxD7Vp+hDVpzNdffWXw+RgjITuPxJx8i66V0I/ZcxR69epl+F0DsGbNGp3P9+3bZ+4SJpFy6RqBLcTdcywhoY+yng7DHuxGVM8uHPrnIonpmYQE+NGjXUtBIwm2TjkUFRWxZMlSAJYsWcoTjz+meedqo5TDnHkL+Prb1Sx/71169ogkMSmRS5evVDhPLVOgUhVSr149Nm5YT0BAAIePHOHZZ6cRHBLCyMcfp6ioiBGPPsozkybx448/UFBQwPETJ0reDT81bjzt24fz6aefoFAoOBsdjbu7+Q62d+/eI+G2xmFToTD+Z3f0mDG8887bXL9+naZNNV4P//77L+f++YdNm34CIDcnh6fGjWPFyo9Qq9V8+OFyhkQN5uKly9Q0wWUyPj6exx9/jGnTnuOZyZM5deoks2fN0jwo03zk5eXRsWNHXnllFjV9fPht1y6enjCeJk2a0KVrVz748EOuXb1Cq9ZteH3RIgDq1KlDbLHg0HL61CmeHP0E819/nccfH8mRI0d46YXp+PsHMG78+JLzVn74IQsXLebV115jy5afeXH68zzwwAM0v+8+E77CGhKy8wBwdxPBWHAXwim9HvIaNsSrWPFL2A5HdTw4Iu1g72hCWU8HhULOAx1a23Q9W0YT1m/6iasxsawCptyMYcNPmxn75JOaBwUWCTk5OXz0yad8vPJDxo/T2PI2bdqEnj166JynLja6cvfwYNGihSXHGzduzNGjR/npp82MfPxxsrOzycrKYtCgQSUvyi1bltaFxMXF8b//zaRFixYANGvWzOw93717l6vXruNjYs6+devWtAsPZ8P69cybPx+A9evW0bVrN8LCNG+Oej/0kM41X3zxJbUD/Dmwfz+DBg+udI0vv/iCpk2b8t777wMQ1qw55/45x/vvv1dyTmhoKC/P/F/J589Nn84ff/zOz5t/okvXrvj6+uLu4UG1atUIDg42uNbKFSvo/dBDzJ2neS7Nmjfn0sULfLj8Ax2h0K//AKZOmwbAK7Nm8/HKlezft88koaAVCB5uGnFaUOkVEubg1LJLqlWwPVWl48Fe2Nsh0l7RhCEyGZOBKLmcJUuWUlRUZJO6hIuXLpGfn8/DvXtXfnJxVOCzzz6jS9euBAWH4OPrx1dffU18cXrU39+f8ePHMWDgQIYMHcZHH31EYmJiyS1enjGDKVOm8sgj/XjnnXe5fv26weWmPfccPr5+JR8ASqWSa9dvEBwcbFbh4pjRY9iwYT2gqf/YuHEDo8eMKXk8OTmZqVOn0LLFfQT418K/lh+5ubnElekQM8alSxfp0rWrZo/FqYZu5dIdSqWSpW8toVP79oQE1iHAz5c/fv9dpwvNFC5fukREZKTOsYjIHly7ehWlUllyrG27tiX/l8lkBAUFk5KaUun9k+9o0gxakSAhPE4rFKRaBQkhsHcRI9jPIVIrEuwRTVhYnI5cqFJx5WYMG3762SbreXt5m3ZisUjYsHEjs2a/ytMTJ/Lb7l2cPnWSCRPGU1BY+p7z22++4dDBv4mMiGDTpp9o0bIVR48eBWDhwtc59080AwcO4P/++os2bdux1YAR3uJFizh96mTJh1qtRqZwo1mzZtQxUpOgj1FPPMHly5c5ffo0hw8fJj4+XmdI3dMTJxAdHc3y5R9y4O+DnDx1moCAAAoKzHsvbaxocfkH7/Ppxx/zv1mz2PPHnxw/eYq+jzxi9hqm4u6mm9KRyWSoVMYnk2r3L4kE2+K0QkGLFFVwLRwxjdFeaQd3L4XdbaRtKRLKRhM6Fh/rRHFU4Y03NVEFgWnWLAxvb2/2/vWX3se1KQcthw8fJjIigmnTptGhQwfCwsK4cb3ihNcOHTrw2muvcvDg37Rp3Zr1ZYr2mjdvzowZM9jz226GDx/OmjVr9a4dGBhIWFgYYWFhhISE8O+FixQVFeFpqrgpQ7169XjggQdZv24d69evo0+fPjpD6g4fPsz06dMZMHAgrVu3xtPTk7Q001OFLVq05MTxE5pPikXCsWNHdc45cvgwg6OGMObJJ2kXHk7jJk24evWqzjkeHh46UQF93NeiBUcOHy5370M0a94chcKyF/hCpZpClRoZMjwsvIeE6ThljYIWqVbBNbFXfYIjogn2wh4zE7TRhA3lji9Uqeh88yYbNv7E2CdHC7qml5cXs1/5H6/OmYeHuwc9IiNITUvl3wsXefrpSRVmJTQLC+P7739gz57fady4ET/88CMnTp6kceNGgKa9+6uvviYqajB169bl8uUrXL12jbFPjeXevXvMfvVVHh3xKI0bN+LWrVucPHmSEcOHG93jnTt3uHr9BnVD6uLm5k5cXBwZGRnEx8WjVCpLOg/CwoxbSY8eM5o3Fi+moKCA9z/4QOexsGbN+PGHH+jUqTPZ2dm89uqreHubLkgmTZ7Chx8uZ85rs5n49CROnz7ND999p7tGWBhbtmzhyOHD1KpVi5UrVpCSnKxTw9GwYSNOHD9GTEwMNWrU0OvhM+Pll+kR0Z2lby3h8cdHcvToUT7/7DNWfvyJyfstS6FSE0VwdPOlQi4jKMB8EVgeDycovBT/Dk1AiioIj6NHN9sLKZpgGdpowgCZjNZAfpmPNsAAG0YVFsybw8wZL7HwjTdo1a49Tzz5FCmp+n9ep0yZwvDhwxg9ZgwRkT1Iz0hn2rPPljxerVo1Ll2+zOMjR9GiZSuenTaN56ZNY+qUKSgUCtLTM5gwcSItWrbiidFj6N+/n05xZHny8vK4eu06oXXrUruOZk7CokUL6dK5E4sXLyI3N5cunTvRpXMnTlXSZvnoo4+Rnp7O3bt3GTp0mM5jq1Z9xX+ZmXTt0pmJE8Yz/YXpRsfia1Gp1ChVaho0bMCGTZv45Zdf6NKpI1+t+pLFby7ROfe1ufPo0KEDUYMG8kifhwkKDiJqyFCdc16eOROFQkGHdm2pFxKs0xqvpUPHjvy4fgM/bdpEx/bhvLF4Ea8vWqRTyGgqJSLB0SqhiiFTG+t1FAnZ2dn4+vryXucBeLtVbE3yio11qVZJz/REfO9r6tA9KPLS7F7IqE072DOiYA+hoC1gtGdtgikiIU8lI05ZjcYNGuDl6WHWGvsO/M1D/Sufsvp/f+yh14MPmHVvcxGTh4NSrRlKV7OmfSYumoMzezboEwj5eXnEx8ZSVLMOuOn+/ObmZNOrVUOysrJsMv3y4MGDDBoxkue++d3qe/04ZwJLX5vB2LFjBdiZbXDq1IOE6+FqIkGLvQsYbU1Et65s/GEt+fn5oK0LKFcf4OnpQUR34YZG6UMsIiE3N5fEpBSahjWVRILASFEEx+MSQiGvYUNpAJOEKLF3OyTYxxnS09OTx0cMd6iPg1hEQk5OLtdv3KBe/fqI8ZVYEgkS1uISQkHC+bFnt4O9ixhdLZpQggjMnhz9CpKbWyoS/P0DHLoXfTirSJAEgrhwiWJGKI0qSDgv9pzGaM/aBHtgj5kJenGQSHCkG2RZ3Dw8adCwoSQSBEQSCeJDiihIVMARhYz2wlWjCWBnkWADsydTcbQbJGgKrO/cyyMoKBgPD09Hb6cCSpXa6QQCSCJBrLhMREGLFFVwPuw9ZMlVownmov1bbHbjUxWvS8jOzubGzRg8RSoQnFEkFCrVFCrVyGSmf2vVqBF9y56L4FIRBWkAk/Niz7SDKShVKo5cvE5SZjbBfj5EtGyKwswXRrFHE9xkalCruZuXj7eXmS96VVQk3Mm9w42bMTRo0AC/WrUctg99VLVUQ/69exqpIHeplzFR4pJfYakDQkIfprZE7jgezfw1W4nLyCw51sDfjyUThhPVNbzS6+0dTbA05aCQga+sgJTi0b/VvDxL7JUNIpeDzPj8fVugGc1c6PCYdO7duwQGBuLlXY28vDyH7qUsKmcVCSrzpyyqUZN/7x5pqamo3Ks7tpi2iuByQkGKKjgXjvB2MMaO49GMX76awcBGNFMGzwNLMzIZv3w1a2dONEks2COaIESXQ6BbERTdIyUlufIX4ZJ5CXZ+NSqZz+C4V8GiokKKVGo8PTwAGVlZ2Q7bS3lUaucUCcoSkWDextVoxILKvTpU9xN+YxIVcDmhoEWKKliGI0Y32yPtYEoRo1KlYv6arQwGtlFawNO9+PNhwIK1WxnYua3BNIS95yZYW8Aok0GQexG11UUUqWWGc75e3oASmUd1q9azBKVHNWRujqsHuJ2YyNPPTmPQoME8+9x0h+1DH1n5mhHZcieq/iuxhbbGzEnuJkUS7IhLCgUpqmAdrtrxUFna4cjF68RlZLKRilW+cmAOEJmeyZGL1+nZupnB+zhLNEHnfjJQyIyUhilkyLxqCrqmKSg9a+Dhbuf5EGWIiY3jkcFD6dv3EV6YMbPy1IwdybhXhMJdgUIunj1VRkJ2Hig8JFtoJ8OlJZnUASEBprdEJmVqwsltDDzeptx55bGX8ZPdZyZ42z+KABqRIHOgSAD4+KtveeSRfrz/4UrRiQTA+UQCSCLBCXHJiAJIUQVnwJ0cu3U7mFLEGOynmdF/Hk26oTzny52nc38nSzmYTLFIsHc0Qelp2H7ZHsTGxeHuE8DCRYtRuHlIIsEKJIHg/LisUJCQMJeIlk1p4O/H0oxMnRoFABWwDGgY4EdES/3Ons6YcjCKg0WCo6IJN27G0GfQEJ5/fjrTpr/okD3ow9kEAri2SHCTy2hU23pB6+Uu/q+NS6ceQEo/mIMjChltjTkukQq5nCUThrMTTeHiESCn+N9hwE7gzfHDKxQy2iua4IgxzVVNJFy/cZOHB0YRFTWEZ59/wSF70IckEiQciUsLhbyGDR29BafDXoWM9kw7mENU13DWzpxItL8fkYAPEAn8E+BntDXSXsOVXLkuwdEiAWDy9JcYNmwYS995TzTpBmcTCQnZeSRk5+HhppBEgosgpR4kXBZLfR2iuoYzsHNbkyYz2juaYBcckHJwtEhIT8/As1Ydvvv+B2oF1JFEgoVIUQTXxKUjCuB8rpKe6Yn43qc/By5hPpb6Oijkcnq2bsZjPTrRs3Uzo+ObbR1NsGvKoQqKhKvXrtMp8n7+b+9e/GsHSiLBQiSR4LpIEQUJu2OPtIM9XCLt2engynUJ4DiRcOXqNfoOGsLjo0bxcN9+DtmDPpxJJEgCwfWpMkJBmtQoPpQqFcdvxJOck0tQzRp0bVLfbOMlY9jDJdJe0QS74KC6BEeJhLy8PAYMe5RRo0ezcPESUUQSnEkggCQSqgpVQihIMxUqR5GXZteJjLvPXeLNbX8Qn1Xq9VDftyYLhvVlQNsWdtuHpdgjmlBVUg6OoKioCKVnDTZs+olWrdtKIsFMtAIBJJFQFXD5GgUJceFODnuuxTF17RbaZ+XotCC2z8ph6tot7D53yao1zGmJtAZ7dDq4ukhwRDTh4qXLtOnUnbjYWFq3aSeJBDMpG0WQRELVoMoIBWcranRVlCoV7/x9psR4qTtQg1LjpcHAku1/olTZ38rYVOwxqtmuKQeqjki4cOkSfQcNYcSjj9KgURO7r68PZxUJElWHKiMUJMTByYQU4rNymIth46W4zGyO34i36P72KGK0NY5IOdgLR4qEuPh4+g4cwvgJE5n3+iIpkmAmkkioulSJGoWySEWNjsOdHFLu3AMqN15Kzsm1fB0bph3sZfzkqikHcFyHg19IAz5cuZJBUcMkkWAGkkCQqFIRBWlSo37sWchYr5FmnfMGHtceD6ppfqGbK0UTbI6D6hIcIRLOX7jAwBGjKCwsZPCQ4ZJIMANJJEhAFRMKEo6na5P61PetyVI0Rktl0RovNfDzoWuT+hbdX4ommLFOFehw+PfiRfoOHEKXLl3wruZYR0otkkiQcDaqpFCQihrtjzuaNkiFXM6CYX2NGi/NH9pH0HkKQmCvdkipLkE4YmLjGDj0UZ6ZPIVX586369qGyLhXhEIuk0SChFMhrr/GdkBKPzgO7TTGAW1b8OX4EZz1raljvBTt58OX40dYNEfBHi2RtowmuGrKwZHFiwUKT6Y8+yyvzVtg97XLk3GvqEQkiBnJ0ElCH1WumFGLVNToWAa0bcEjrZvbdDKjUNhrVLPNowlVRCSkpqbx3aYtTJ02jZf/N9uua+tDSjVIODtVUihIkxpLsUchozbtUGFtuZyIMOsjPPYoYnSJaAJVQyT0GTyUFi1aMGXa83ZdWx+SSLA/NzLucjf3ns3XUchl1KvlbfV9PN3E9+aoPFVSKEjYH1ubQNkq7SDWaIJSqeTgqX9ITE0npE4APTu1Q6Ewslfv6lVKJHz17VrjXw874AwiwdUEgpZqHs7/fMSE2VLmwIEDREVFUbduXWQyGdu2bav0mn379tGxY0c8PT0JCwtjzZo1FmxVQqIirhBNMFckbP1jPy36PE6fCS/y1KzF9JnwIi36PM7WP/brv8ABZk+OqEk49s8F2rZtx1ffrsXNzbHvgSSRYF+0IqGah0ISCTbAbKFw584dwsPD+fTTT006/+bNmwwaNIjevXtz9uxZZsyYwTPPPMOePXvM3qzQSN0PtsdQ2kHQNZw0mmBJymHrH/sZNWM+bZNTdTpG2qakMmrG/IpiwQF1CfYWCSmpqew9coLeDz3Eqm9WSyKhErQFi+D8IuFGxl1uZNyVBIKNMfs3asCAAQwYMMDk87/44gsaN27MBx98AEDLli05ePAgH374If36Oc7/XapTsB+2Sjs4ezQBzEs5KJVKZi9dyWC1xhdDq/K7A9vUMEwGry77iCEP9dQJu7u6SOg7eBgdO3YkIvJ+u65dHrELBHDdKIKEbbF5FcWRI0fo06ePzrF+/fpx5MgRg9fk5+eTnZ2t8yEhPPa2lrYFzhxNMDflcPDUP8Qkpxr2yVDDzaQUDp76R3PQAXUJ9kQrElq2bMXKTz63+/plkUSC/ZCiCPbH5kIhKSmJoKAgnWNBQUFkZ2dz757+ytRly5bh6+tb8lG/vmVT+iQciz3SDrbEVtEES7scElPTgcp9MhJT0+1al+Co4sXPvvmOli1bOTzdIHaR4GqpBpCiCPZGlF0Pc+bMYebMmSWfZ2dnS2LBSbFl2sFZowlg2cyEkDoBgMYPo7uex7U+GSH1NF8Xe0QTHCESUlJTyZd58L9Zs1Ajl0SCESSBICEENo8oBAcHk5ycrHMsOTkZHx8fvL3196B6enri4+Oj82ErxFTQ6JmeiO99TR29DQnEF00A6NmpHY2C6rBUZsAnQwaNgwPp2aWDS4uEPgOH8MXnn6Nw85BEghFcQSRo0wwgiQRHYnOhEBERwd69e3WO/fHHH0RERNh66UqRxjnbDlumHWxZxGhL4yetSLB0AqNCoeDduS9pfDJk5XwyZBqfjHcWzsKtup8wGzaCI0VCm7btHOrdUHYcsxhFgqukGqSWR/FgtlDIzc3l7NmznD17FtC0P549e5a4uDhAkzYYN25cyfnPPvssN27cYPbs2Vy6dInPPvuMTZs28fLLLwvzDCQswh6FjLYcsmSLtINYUw5lGd73QTauWMK5wDo6PhnngwLZ+Nl7DO//sBDbNIqjahKmzXiFNm3b8cVX3zgskuBMUQRnFQlSFEF8mP3bdvLkSXr37l3yubaWYPz48axZs4bExMQS0QDQuHFjfv31V15++WVWrlxJvXr1+Prrrx3aGinhvNi6JVKMKYfyDO/7IEMe6qk7mbFnBAqFwm5dDvYUCdnZ2chr1OLDlSvxq1VbEgkGcLUogoR4MPs3rlevXqjVaoOP65u62KtXL86cOWPuUhJOiq27HZwtmmBtykHvPRUKHuzaoewBu9UlOCLdMPOVWYx8Yozd1i2PJBJsizR+WdyIsuvB3khOksJja28HcygoKuKbPQe5kZJGk8DaTOrXEw8970ptOVzJps6QdmqFtPeshLI1CSMeG2nXtcsiZpHg7AIBpCiCM1DlhUJVnNCoyEtz9BYswpKWyNd/3M6qnfvILxMFW/zDdqYM7sUbTw4F7BNNsBl2GtFs77oEpVLJwOGPSzUJRnB2kSBFEZyHKi8Uqiq2KmQU05Cl13/czsc7/mIwMA/NQKLzwFtqNR/v+AugRCw4ZTTBRUWCSqUiT+7JipUf0a59R0kk6MFVRIIkEJwD8RthSzgdtkg7mFvEWFBUxKqd+xgMbEczoKhG8b/bgcHAql/3oZYbrrexFkvGNJuLq4mE5JQUuvfqw/nz5+nYuaskEsrh7K2PUkeDcyJFFCScBnPSDt/sOUi+Ws089PsizAV2qtSs+u1vXpowSsBdarBXysEe2EskaGsS2rYLp1XrtnZZUx9iFgngnAIBXC+KoJDLCK7hafV9PBTif78u/h3aCTFNaHRWbJV2sKQl8kaKpg6jMl+EG0mplm3KBFwl5WAPcnNzGTRiJK1at+HLr7/Vcb+0J5JIEB4piuD8SEKBqjWh0daFjLbqdjC3iLFJYG2g1P+gPNrjYU0aW74pA9g05eCidQlqbx/GjZ/gMJEg5mmLzi4SQJqu6OxIQqEK4kzW0pYOWJrUryeeMhlvod8XYSngKZczdZiwg79snnLAtURCVlYWE6e9QOZ//zFp8lQ8PDxsvmZ5xBxFSMjOc8opi1IUwbWQhIKEINiy28GSAUsebm5MGdyLncBQdH0RhqLxRXhu5CA8PIQv07F1NMGW2Fsk9B/6GCkpKdTw8bP5evoQs0gAKYogIQ6kYkaR4Jme6OgtWI3QaQdrxzVrWx9X7dzHzjJzFDzlMl4eOZilz4216v7lcfaUg71FwoBhj1HL35/v123E09P6ojBzEaNI0AoEcD6RIEUQXBdJKIgIW1tMO+OgJWvHNb/x5FDmjxpUMpkxLDSQKf3vxzu4rkA71GDTlIOLiQSAjDwlHTp24s2lb+PlZV9zKRC3SHBWgQCSSHBVJKFQxbBFfYIt0g5Cmj95uLkxbVAvwDY20rbwcijBxURCdnY2X/+wkSnPPst7y1fYfL3yiFEggPOLBEkguDZSjUIxeQ0bSi2SVmCLbgehzZ9sIRK02HKwkj3MnuwhEnJychg4YiR//P47RUrbDboyhBhFgrMWLErFilULKaIgIQhKlYqj12LZce4SUW1b0D2sIQq56+tQIVIOSqVS1zK6UztNi6CdihftKRJqVK/Bjxt/snt3g1hFAkhRBAnxIwkFCatwJ4e//rvLm6s/JT5Lk4L48cgZ6vvWZMGwvgxo28Lse1pi/lTpPkWactj6x35mL11JTHLp4KdGQXV4d9Fshvd/2C4pB3tw7NxFatWqxervfrR7TYIkEoRBEghVF9d/yycBaAoZbVGfsOdaHFPXbqFNVg7aunUvoE1WDlPXbmH3uUuCr2kutnSHtFYkjJoxn7bJqTrtm21T0hj13Gy27T0s1DYrYK+6hNzcXP7v6EkiIiJZv+lnvL29bbpeecQmEpzVq0ESCVUbSShIWIxSpeLtfScZDNQD8oFVQB5QH43x0pLtf6JUlR95ZBghixjLYqtogqUolUpmL13JYDVsQ9e0aptazWBg9utvoVQqrd5rhbXtKBIGPTqK5e+/DzIFMpl9X6zFKBIAp6pH0NYiSDMRqjaSUJCwmOiE69zKvctM4Hs0wmAyMKj485eBuMxsjt+IN+u+QqYdxBpNOHjqH2KSU5mLftOqOWo1N28n8vexk9ZssQL2FAmDH3sCd3d31ny/ThIJUhRBwomRhEI5pM4H00m5cw+A79BEERYXH18M3AN+KP48OSfXpPs5UzTB2i6HxNR0oHLTqqTkFKvWKYs92yC/+n4DCoWCDT9toVq1ajZfryxi82xwNpEgRREkyiMJhTK4qjmUreoTAqtr8s3r0EQTOhYf74QmqrCu+POgmqYXzYk9miDUYKWQOgFA5aZVwUHCiBx7iYQ7d+4Qm/ofk6dO5act2+0qEsoaO4kBZ2x9lKIIEvqQhIKERbiTQ89unanu7k4+pdEELYvRRBlqeLjTtUl9+2+wGFvMTRBiZkLPTu1oFFSHpTL9plXLZDIa1w3h/m6drV7LniIh6vHRvLVkCXKFu127G6RUg3VIUQQJY0jtkSLAMz3R5uObbUFhkYqioiL6Aa3RFDNqaQP0A/YVFlFYpELhYVyTCt0SKeZoAoBCoeDduS8xasZ8hslkzFGraYMmkrBMJmMnsOmNeYJZLttaJNy9e5chI8egVqt5a9m7Nl2rPJJIsA4pimAZCpmMOtXcrb6Pu0IcP7fGkCIKEhbzw5HT5KvV7EHTEln+Yw+Qr1bzw5HTDtmfkNEEW4xpHt73QTZ+9h7nguoQCfgAkcD5kGA2ffUxwwdZb4Ftr1kJL899HaVSyaaft1G9uu0HRWkRk0hwtlSDFEWQMBUpouDi2MIIyp0cvOo1YGTtQBKysskrKESNmpTsO9wrLMDb3YNAn+rIkOHl4c7Ibu2M3k/oIkZbdTrYYkzz8P4PMzQqir+PnSQpOYXgoEDu79ZZkEiCPVIO+fn5FLpXY+68eXhXq1mlRQJIUQQJ10QSClUAWxQyAvh4ebFwSB9B7iX0JEZbRBMEx7s6Mq+aKIBekd0EvbU9RMK9e/cYOupJ+vXrz7TpL9psHX1IIsEyqoJAOJ+YTd4d0zqtJExDEgp6SLl0jcAWYY7ehigx5hSpVquJjk8kvH6IyX3z5kYTlCoVRy5eJykzm2A/HyJaNtXxlNAXTVAqVRz65yKJ6ZmEBPjRo11LFArzsm6CRxNs6ONgD5GQnZ1N1OOjARg7fqLN1tGHWESCViCA+EVCVbCCPp+YXfJ/Xy/ppU1IpK9mOfIaNsQrNtbR2xA1hpwit5w+z4z1O1g5eggjOhmaEFARU6MJO45HM3/NVuIyMkuONfD3Y8mE4UR1DS85VjaasG3/MV77aA2xqRklxxrW8eftFycw7MHK38ULMTOhAnawjralSFCr1YwYM45q3tX4fv1Gu7dAgnhEgtgFArh+FKGsQPDz0hQX3ruTZ+h0CQuQihldGFvUJxiiSKnioz0HAFi55wBFysrHNpsTTdhxPJrxy1cTnpGp44sQnpHJ+OWr2XE8uoLx07b9xxizYDntUjN0rmmXmsGYBcvZtv+Y0TVtlnLAdiLB1m6QarWau7jz+sJF/LBhk91EQtkZCZJIMA1Xt4I+n5hdIhL8vNxLRIKE8EhCwcURsj7BWNph+9l/uZGRxSrgRkYmv5y9YNo9TYgmKFUq5q/ZymD0+CKgGfa0YO1WlGXEiVKp4rWP1hi9Zs7Ha3Wu0YctognOKhJyc3PpP/Qxjh07Sueu3e1m8CSmKIKzdDWUFQiuKhJAEgj2QhIKEmahL+2gjSYMQeP1ECUzPapgCkcuXicuI9OwLwIQm57J0VvpJccP/XOR2NQMo9fEpKRz6J+Lete0ZcrBFti6DfLOnTsMfuwJlCol7cI7Vn6BQIhJJIDzRBFcWSCcT8yWBIKdkYSCg/FMT3T0FqxGG01YWPz5QnXlUQVzBiwlZWrePVTmi5CYnllyTPt/c67RYpOUgw3rEmxdvJifn8+QkWOQy+V29W6QRIJ5VIU0gyQQHIMkFESALaYyCl2fYCjtUDaaUNbrQcioQrCfD1C5L0JIgF/JMe3/zbmmLLaYmeCMIgGg0L0aQ4YOY+PmrVVKJGhTDSBukeDKUYTydQgSjkESCi6M0PMT9KUdykcTtBiLKpg7rjmiZVMa+PuxFAO+CECjwAB6tGtZcrxHu5Y0rONv1jVgu2iCM4qEe/fu8eyMWaSmpjJ56jS7DFMSS9FiWYEgdpEArhdFkAoVxYUkFCQsRhtNGECp14P2ow0wQKCogkIuZ8mE4ewEhoFOB8MwYCew7IXxOrMRFAo5b784wbxrbDCm2VZ1CbYWCXl5eYwYPY7z589Rrbrt2jjLIoYoAjhHqsFVowiSQBAnklCQqBRDaYcTN+O5kZHFbvR7PewujiqcuBlfco2l45qjuoazduZEov39dHwRztX2Y92bM/XORBj2YDfWvTmTf+r4614TGGDwGluIBKGjCfaoSRgxZjzZOdls3voLNWvaXiiIQSQ4Q6rBVVseJYEgbqSBSy6ILeYn6Es7dGwUyudPDaegSGnwOg83BR0b6aYZLB3XHNU1nIGd25ZMZgwNrMUDPSOMTlkc9mA3onp2qXQyo+ApBxsPVbJlTUJqbj7BwUF8s+Y7fHx8bLaOFrGIBBCvQADXTjOAVIMgZiShYABnH+NsK3+Hsni6uTE4vGXlJ2rPF8D8SSGX07N1swrDlYxeo5DzQIfWhh+3RcoB2xUv2kokFBQUsOr7DYyfMIFPPl9lkzXKI4mEynHV8cuSQHAeJKGgB1PHOCvVai5kppFRkIe/hxet/GqjMNHjQKwoVSpOJSSSeucudapXo3toDbwaNBLs/kKbPwmFM9Ul2ILCwkJGjZ/ErVu3eHzUaGrW9LDZWlokkVA5rhhF0DdyWULcWCQUPv30U9577z2SkpIIDw/n448/pmvXrgbPX7FiBZ9//jlxcXHUrl2bxx57jGXLluHlZbvwqa05nJrAmqvRJOXfKzkW7OnNhGbhRNYR54thZfxx7Qbv7TvIrdw7Jcfq1ajG64/2Z0DbFlbdW0graXOiCZXhLCkHW9YlFBYW8sSEZ4iLi+OXnburRE2CswgEcB2R4GoCQSYDX0/rvzfO8ObS7GLGjRs3MnPmTBYuXMjp06cJDw+nX79+pKSk6D1/3bp1vPbaayxcuJCLFy/yzTffsHHjRubOnWv15h3F4dQE3jl/lM7593Sq6Tvn3+Od80c5nJpg0n080xMFn6FgaX3CH9duMGPnHjrk3tF5Th1y7zJ17RZ2n7tk9d6EiCboc4e0FMFTDk4oEgBOXbhKcnIy23fsopa/8PMjyiOJBOO42vhlqVDR+TFbKCxfvpzJkyczceJEWrVqxRdffEG1atX49ttv9Z5/+PBhevTowZgxY2jUqBGPPPIIo0eP5vjx41Zv3hEo1WrWXI1mELAdXQ+B7cAgYM3VaJRqtcP2aG59glKl4r19B436IizZ/idKlWVtjkJGEwDBogkg/roEW4qEoqIi/j4ZTdt27djz51/4BwQIvkZ5HD0jQcwiwRU7GiSB4BqYJRQKCgo4deoUffr0Kb2BXE6fPn04cuSI3msiIyM5depUiTC4ceMGu3btYuDAgQbXyc/PJzs7W+dDLFzITCMp/x7z0O8hMBdIyr/HhUz7OTday6mERG7l3jHqixCXmc3xG/EVLzYRsUYTBMMGQ5VsLRLGPjONmS/PQKWWIbNx+LPsICVHIHZDJ1eNIkgCwTUwq0YhLS0NpVJJUFCQzvGgoCAuXdIfmh4zZgxpaWn07NkTtVpNUVERzz77rNHUw7Jly1i8eLE5W7MbGQWadySVeQhoz3MGUu9o/khV9pySc3Ltsh9jCBFNsFXKQUhsKRKUSiXjpjzPhX/Ps2PXHhQK274wSakGw7haLYKr1SFIaLD5wKV9+/axdOlSPvvsM06fPs2WLVv49ddfefPNNw1eM2fOHLKysko+4uMtfycrNP4emj/clXkIaM+zJ5bWJ9SprpnfX9lzCqppftW9ueOaDSFkNAHEX5cAtqtJ+HHLDv6JPssvv/5GnUDh0jj6kESCYVwpiiDVIbg2ZkUUateujUKhIDk5Wed4cnIywcHBeq9ZsGABTz31FM888wwAbdu25c6dO0yZMoV58+Yhl1fUKp6ennh6epqzNbvRyq82wZ7evJV/j+3oKi0VsBRN90Mrv9oO2Z8l8xM6hYZQr0Z1lubeYRsVn9MyoIGfD12b1Bdkj5YiZDRBSGyRcrBVd8OtjBxGPPooffsNwNfXV/A1yuJIkaAVCCA+keBKUQQpglA1MCui4OHhQadOndi7d2/JMZVKxd69e4mIiNB7zd27dyuIAW2oU+3Agj9LUchkTGgWzq/AUHQ9BIYCvwITmoU7RcuLFoVczqxePY36Iswf2geFHlFnDKGKGIVqh7RFysFWdQlCc/fuXYaPforXZs9GrnCvEiJBjPUIrhJFkCIIVQuz5yjMnDmT8ePH07lzZ7p27cqKFSu4c+cOEydOBGDcuHGEhoaybNkyAKKioli+fDkdOnSgW7duXLt2jQULFhAVFWXz3KitiKwTyqtturPmajSR5eYovOqkcxT6hjVhxeB+vLfvIJFl5ig08PPhy6F9LJ6jYG3aQewpByGxVV1CVlYWgx4dhZubG199u1bQe+tDLCJBTLhiFEESB1UHs4XCqFGjSE1N5fXXXycpKYn27dvz22+/lRQ4xsXF6UQQ5s+fj0wmY/78+SQkJFCnTh2ioqJ46623hHsWDiCyTijdate1eDKj0DMUFHlpVo9t7hvWhIeaNCI64Tr/eVUnqGYNujapb3YkAYRtiRRdysEGdQm2LF58Zf4ifHx8+WH9RpsOOdMKBJBEQllcpeVREghVF4smM06fPp3p06frfWzfvn26C7i5sXDhQhYuXGjJUqJGIZPRtlYdR29DULzkd3gwwvCUTXMQSzTBFl4OziAS7t69i9KzBosWv4F39Zp2EQmSQCjFVaIIkkCQkLweJHQoKCrih/3Hicn4j0b+tRjXoyMebpX/mBQUFfHdodPEZPxHWB0fJt7fnsr+rChVqhInyGA/HyJaNq0QvRBquJIlIkGtVnPy/CU6t2lROmdA4LoEW4mEO3fuMPixJxgwcCDTX3xZ0HuXRxIJFXGFKIJUqCihRRIKEiUs/3s/35++SH6ZItO3d+5l4oNdmTf4YYPXvbVzL6v3H9e5bsn2fUwZ3Is3nhyq95odx6OZv2YrcRmZJcca+PuxZMJworqGC17AaAk/7tjDxNfeYs3b83lySD+bmT0JLRLu3bvH0FFPAjBx0hRB710eSSToIgkECXtgrt+Stdh8joKE7RGiPuH9v4/w9akL9FWrdboe+qrVfLHvGG/t3Kv3urd27uWLfcf0Xvfxjr94/cftFa7ZcTya8ctXE56RqXNNeEYm45evZteZc1Y9Fy3WpByKiopY+olmLPnST76lyF3Trit0NMEWNQljn3mWgoICNm7eSvXqthE34DiRINYpi84uEqROBufAXL8lIZCEggQFRUX8eDqawej3rxgMrN5/nIKiogrXrd5/3Oh1q37dp3OdUqVi/pqtRn0l5n3zM/gKM4fC0rqEDbv+5OqtRFYBV27dZuOOPaIXCWq1mjtqN2a8PJOftmynRg3b2VI7yrNBrFGEGxl3nbrlURIIzoO5fktCIAkFA+Q1bEjKpWuO3oZdWP/Pv+Sr1Ub9K/LVar47dFrnse8Ona78OpWab/YcLDl+5OJ14jIyjfpKxKRlcuifi1Y9J2tSDtpowhCZjMlAlEzG0pWrKConlCzFFrMSCgoKePypifz1f/9Hpy7dbGYV7UjPBrGJBFcwcZI8GcRBYWFhBX+j/Pz8CudZ4rckBJJQcABCtkZaOra5LPGZmncTlXk9xGT8p3Nc+3ll191IKd1jkolrJaZnGtpupVjb5aCNJiwsrrlYqFZzJTaejdt+tXhPWmxRvFhYWMgTE54hNjaWjp1tl6eUUg2lOPvgpPJpBgnzkaOmmjrP6g8FKnbs2IGvr6/Oh3YWUVmM+S0lJSXZ7LlKxYwugLX1CfX9fACNp0N3PY9rvR4a+dfSOa79vLLrmgSWphGCTVwrJMCv0n0bw1KRUDaa0LFYKHQCouQy3np/JaOGDcLNhC4QfdhCJCiVSp6cNJXY2Fh+2bkbPz8/we5dFkeKBBBXFEGLswoELZJAEA9RUVGsWbNG55iYbAykiIIE49o1wFMm4y003g5l0fpXeMpkjOvRUfe6Hh0rv04uY1K/niXHI1o2pYG/H0sNXLMMaBQYQI92LS16LtYOViofTdCyUGVdVMFWbZD3ZB5ERPZg2y+/UstfuDkRZZFEggZnjiJIhYrixt3dHR8fH50PfULBEr8lIZCEggQebm5MfLArO9HvX7ETmPhg1wrzFEy5bsqgXjrXKeRylkwYbtRXYtkL41EoLP/RtDaaMEAmozWQX+ajDTCgOKpgbq2CrSIJsxe+SUJCAlOnPU9AbduYkDlCJIgt1eDMtQiSQHAtLPFbEgIp9eDECFGfoEU7J2H1/uPsLPNu2lMm41kjcxTmDX4YhVzF13+d1L1OLuOFQfrnKER1DWftzInMX7OVyDJzFBoFBrDuhfEMe7CbRc9B4ell1fTFQ6fPcfVWIlcBvS/pKjXExnPw+Cl6RZq3RyFFgkqlYtLzL3Hi+HGmPf+CYPctj6NEAogziuBsSDUIrkllfku2QBIKTo619Qnu5OBVrwGgedGf1f/BkgmLpkxm9HQvZOHQXrz+9Ci+2XOQGylpNAmszaR+PY1eF9U1nIGd23Lk4nVS7+QS2rAhPdq1tDiSIISXQ/f2rVn/yTvkFxQgc/fWe46npwcRndqbfE+h2yBVKhVTXpzJsaNH2fnb7wQF2SbcWNVFgjPXIkgCwbWpzG/JFkhCQUIHDzc3nnnQvMp5rafDtEG9zLpOIZfTs3UzwaYwWuvl4Olbi8cG9RVsXoIt2iBT7xSQk5PLL7t+IySkruD3B/uLBDEJBHDeKIJUqFjK6dj/Kj/JiTHmt2QLJKFgZ4R2jbQGd3IcvQVBRIK1KYeyCC0ShIomqNVq1m7ayohHH2X1dz8Ick99SCLB+USCJBBKORGTAUDtGh4O3olrIQkFK1Cq1RbbTJtLgaqIn69dISE3l9AaNRhZr7ZF9s/l0aYdStYpY+5UWerB071QxyFSrVZz5kY8HZrULzVRMoLcXcaBc1dJKbxKSICfRakHU1IOSqWSv09Gc/jMOSI7tOX+zuEoFOVeCAT0cbCFSJg593W2bdvGA716ExwcIsh9y2NokJJSqeT4kUOkJCcRGBRM14geFb9+FiAmkeCMAgGkNAOUigOAOsUCIf9ugaO245JIQsFCDqcmsOZqNEn590qOBXt6M6FZOJF1rLNXLs/H0afYfOUi+ZQWC34RDU92as8rVtYolEWfuZMpplBaNv59kmmf/cgXz49l1P2djZ6743g0C9ZuJbbMYKWGdfx5+8UJZhczGosmbP1jP7OXriQmObXkWKOgOrw79yWG931Qc6BYJAgRTbCFSJi98E22btnCr7/9YRORYCyKsHvHdhbPnUvi7diSYyF1G7Jw6VIGROk3/DIFSSRYhxRF0C8QJGyD1B5pAYdTE3jn/FE659/Tae/rnH+Pd84f5XBqgmBrfRx9ih+vXKAv5UyXgG9PneX9vy0b21k+7WDM3EmfKZSne6HO50VKJe9v3g3A+z/tpkipNLi21hSqXbquKVS71AzGLFjOtv3HTHoOlaUctv6xn1Ez5tM6ORVt3KQh0Do5lVEz5rP1j/2iFgkAF2MS2LVzJ7/8+huNmzQR7L5aKhMJ0yaOJfF2O8o2siYltmPaxLHs3lHR8KsytK2P4HiR4IweDVK7o0YgaEVCnRoekkiwA5JQMBOlWs2aq9EMQr8R0iBgzdVolOUG9lhCgaqIzVcuGjVd+vF0dAWzJlPRph1MMXfSZwpVNu2w+dBprqdksAq4lpLOz4fP6F3TFFOoOR+vRaksP45Jl8pSDkqlktlLVzJYDY8DccAqIBYYWbzOq8s+QqlUilIk5OXlsefAERo2asTRk2cIa9ZMkPuWxZhIUCqVLJ47F7W64ndKrd4GDGbxvHkojQjC8pQVCI4UCc44F0ESCJJAcCSSUDCTC5lpJOXfM2qElJR/jwuZ1s84+PnaFfKp3Kxp/T//mnXf8tEEk8ydyphCGYomDJFRYqJkKKpgkilUSrpRUyhTvBwOnvqHmORUZgNvAUMo3lvx57PUcDMphYPRlw3ew1SEFglZWVkMGP44S99aghq5IPUA5amsaPH4kUPF6Qb93ym1eg6JCTEcP3LIpPXEFEUA55muWNUFglYcnIjJKBEHkkCwP1KNgplkFGj+4FVmaqQ9ryzmdjwk5OaatJbW1MkcyhYxmmruVNYUSl80YVPx5wvVajoXRxXK1yoIZQpVWZdDYmo6ABeBq8AG7d6AzsAl7X6SrfNwF1okpKdn8MiQ4QQFBbP2h3XIBShYLY8pnQ0pyVqDGePfqdLz9KMVCOBYkeCMcxGqcqGiVH8gLqSIgpn4e2heEM4bePx8ufOsIbRGDZPW0po6WUpZcydj6zTyr2U0mqB1guiE4ahCaKBpaxkyhTJ1sFJInQAAlqCJJujsrfg4QHCQAPMbBKxJ2LB9Jw0bNmT9ps1Ury5cJwboWkRX1v4YWDLIyfh3KtDIwCcxpRrA+aIIVTmCAFJ6QUxIQsFMWvnVJtjT26gRUrCnN638rJ+9/2hYczyp3KxpdLvWJt+z7CRGLSaZO5UxhdIXTVhYriRjoVpdoVbB3UtBj1ZNaVjH3yJTKHPso3t2akdtn5rEoYki6OwNTc1CHT9f7u9mvDvDGEJOXczOzuZyfBITJj7N2h/W4+4u7AuEufMRukb0IKRuQ2Qy/d8pmWwZIaGN6BrRQ+/1Ykg1OFuxYlUVCGXTCyAJBDEiCQUzUchkTGgWzq/oN0L6FZjQLFyQeQoecjcea97SqOnSkx3DjY5KNmkdE02hanrrqgFtNGGADP0mSnqiCh51gnn7xQkWm0KZOlhJrVbj4e5GP/TvrV/x81ZbWHQqpEjIzc1l8GNP8O7by5DJ3QSvSbBkiJJCoWDh0qXATmSyYZT9Tmk+38nCt96qsFexGDo5U7Fi+TqEqoI+cSAJBHEi1ShYQGSdUF5t0501V6OJLDdH4VWB5yi8EN4JgM1XLrITXbOmpzuG88r9pjuGGZvEaJoplO6ApaOXbnA9JYPrGDBRUqshJZ2jl27Qu1OLksPDHuzGujdn8tpHa4hMLc1FGjOFMtfL4dDpc9xO/4/bhvYGkJZukcGTkKOZ7969y9BRT+Lh4cG7H6wQ7L5arJm0OCBqKJ+v/qF4jkJkyfHguo1Y+NYPFeYoiCWKAM4jELRUNYGgxamFgUqFPFcAYz5lYeXnOBhJKFhIZJ1QutWua5fJjC+Ed2Jq23C2XjzDrbt3adKgHqPbtbYoklA+7VAWY6ZQ5WsTALo0b8zqGRPILzTcnunp7kaX5o0BdEY1D3uwG1E9u3Don4skpmcancxoTspBS/f2rVm//A3yCwpQqVRcuZVE5p08/Hx9uK9pE+RyudkGTyB88eL8JW9TVFTE5q2/4O2t34jKUoQYxzwgaiiPDBxc6WRGR4sEZypWlASCkwuEKogkFKxAIZPRtlYdk8611uPBQ+7GmKaNrXaLrHQdI6ZQZaMJoBEBw7q3r/Se7l76/3ArFHIe6GBafYW5Xg6eHh481r+35hOBhioJKRIKCgq4J/Ng1quvIVe426RwEYTxbFAoFET0fEDvY44WCOCcUYSqKBAkceC8OJVQSL5yg0at7nP0NpwSfUWM+lCqVBy/EU9yTi5BNWvQtUl9qnlWPlRHqVJx5OJ1kjKzCfbzIaJlUxRyeYlIsNT4yWrDJxGKhMLCQkaNn0Tr1m2Yu6B8qaX12MvYydEi4UbGXVRKJRdPH+NuZhq16gTSulN3m8ydsJaqJhCk6IFr4VRCQcK27D53iTe3/UF8VmktQ33fmix+9CGGP9Lb4HU7jkczf81W4jIyS4418PdjyYThjHigo1UiQQiEcoQUQiQUFRUx9plniY2N5ZPPvhRgV7oYMnYSGjGIhGN/7mLte2+SlhRXcrx2cAOmzFlI5CODHLKv8kgCQcIVkLoenARFnuVFM6bYSe8+d4mpa7fQPitHpxOhfVYOk77dzo7j0Xqv0/o2hGfo+jaEZ2Qyfvlqth85a9GeLalLqIBAjpBCdjg8/8prXLx4kW2//Eotf2GssUF3RoItcXRXg7bl8difu/jglSmkJYVTtiMjLTmcpTOe4fDvv9p9b2Wpap0MUnujayMJBQN4xcYS2CLM0dvQwZr6BGNpB6VKxZvb/jDqv7Bg7VaUKlWF6yrzbZi3elulvg2GEFPKQQjuqN0YN24823fuonYd02pbTKEqpRoAPBWw9r03QY8PBcU+FKuWLTbLh0IoqtrIZWm8ctXA6YRC4sVrjt6C2XimJzp6C0Y5fiOe+Kwco/4LsemZHLl4XecxIXwb9CGWlINQdQlqtZrnZr7Kzh2/0KFTF4KMTDM0l6ogEsqbOP176mhxusHAT556DmlJcfx76qhd91lVBII+/wUJ18apahS8mzRCdTPe0duwCGs6HmyddkjOMc1TIqmcp4RQvg36sDaaICaR8MKsufz++x5emvk/q+5VnqoiEkC3o+G/VK0/h/GfvNLzbEtVSTFI9QdVF6cSClUZW6UdAIJqlnpKdNfzuHbaf3A5Twnt55VdZ8i3QR9CdTlYg5Ai4X/zF7Fz5w527fmT+vUr7zoxFXuIBDEIBKjY9lirjrY41vhPXul5tkESCBJVBadLPUiYjinRBICuTepT37emUf+FhgF+RLTUjYpEtGxKA38/i3wb9GF1ykGAugQh2yDv4k5o3VB2/PobjRo1svp+WqqKSDDk0dC6U3dqBzcAAz4UyJZRO7gBrTvpExHWU1UKFaUCRQktTikUnLFOwVGYMjtBIZezYFhfo/4Lb44fjqKc5bFCLmfJhOEW+zbow6poAsK0QgohEj78/Gtibt5k2vQXaRomXFGsK4uE8rUIhlAoFEyZsxDYCeV8KCj2oZgyZ6Hg8xSqSqGiJBAkyuN0QqFaWBNHb8GuWFOfYA4D2rbgy/EjOOtbk0jAB4gE/gnwY+3MiUR1Ddd7XVTXcNbOnEi0v5/OdecCA1j35ky9vg36ECKaIERdghDphteXvsc7by/jXl6BVfcqj6uLBDDdCjrykUHMXfE1tYOiocxPXu2gaOau+FrwOQquLhD0FShKAkFCi1SjYGOsHd0MltUnmJp2KMuAti2Iat+Yo9dvkSbz0JmwaIyoruEM7NyW49djSCnEqG+DPqyemSBgXYJV91AqmTZzNr//9hs7d/9Oq9am238boyoIBDB/BHPkI4Po9nB//j11lP9SU2wymdHVfRmk+gMJU5CEggtjStqhPAq5nF49TXekLFmrmju9H+xh9nVarBUJYqhL+C9fRX5eHnv2/iVY4WJVEAnWeDQoFAradbX8584QkkCQkCjFJYWCSq3mWnY62YV5+Lh7EeYTgNwGro6gCTVfy/mPsJq1kJm4RoGqiJ+vXSEhN5fQGjV4NKw5HvKK3wpL0w6WRBMAPN0LUapUHPv3agXPBqPrGTB9MgWrUg4iEQmZmVl88OmXvDJ7Np+v+sbi+5THFiJBrVbzz5nTtOvQEZlM5hCR4GinR6VSaTAKIQmEylEplcRfOM2djFSq+9ehfquOyEXoryEhHBYJhU8//ZT33nuPpKQkwsPD+fjjj+naVb/jIEBmZibz5s1jy5YtZGRk0LBhQ1asWMHAgQMt3rghzmbcZlvMedIK8kqO1fbwYlijNrT3ryv4evuS4/jw4klebtmF3sGVv4v8OPoUm69cJB91ybEvok/zWPOWvBDeqcL5lrZFWhJN2Bl9hUXb9uv1bDBUo6DFEj8HIcY0O1ok3E5MZODwx6lXrx5FSjVCvbTYKpKwddMGXn5uMq8v/4z+w0c6ZRTBGg7//iurli2u4A/R/9lZtHmgH+B6AkHI6MHlw3/y51fvk5OeUHKsZkAofSa/wn2Rfay6t4R4MbuYcePGjcycOZOFCxdy+vRpwsPD6devHykp+oebFBQU0LdvX2JiYti8eTOXL1/mq6++IjQ0VO/5pqKv8+Fsxm2+uXKS7gV5OhX43Qvy+ObKSc5m3LZqzfIoVSo23bwAwE83L1QYcVyej6NP8eOVC/RFrbO/vqj58coFPo4+Jej+zOGPC/8y6dvtBj0bDHk9WBNNAOtSDo4WCQm3b9PrkUG0b9+eHzf8hLe3t8X3KovWs0FokVBUVMTyd94B4OsVy5GXEau2xtSOBlty+PdfWTrjmYr+EEnh/LDoRW4e3etSIkHo7oXLh/9k69szyUnvSNmvX056R7a+PZPLh/+0es9OhUqJ+r8kqz8oErbo2RaYLRSWL1/O5MmTmThxIq1ateKLL76gWrVqfPvtt3rP//bbb8nIyGDbtm306NGDRo0a8eCDDxIebvwdqjH0dT6o1Gq2xZxnELAdXd+B7aA5HnMelVq4P44HUuJJyLvLKuBW3h0OpNzSebxsIWOBqojNVy4y2MD+BgObr1ykQFX8TtKOaQelSsWiLXvN9nrQYk00wSKsLF4UqiYhPjWTQYMH8cnnq3B3t/4FxtbGTmt+WEd87DVgFbfjrvH7Lz/bZJ3ymNvRYAuUSiWrli3W7w9R/FO+acUyVA7whxAaW7Q3qpRK/vzqfTDyV+LPrz9wia+fREXMEgoFBQWcOnWKPn1KQ0xyuZw+ffpw5MgRvdf88ssvRERE8PzzzxMUFESbNm1YunSpUcOW/Px8srOzdT4q41p2OmkFeczT86TkaKbCpxbkcS07vfInagLaaEIUMBnNr4+xqMLP166Qj9ro/vJR8/O1KyXH7ZV2OBN3k7jMXLO9Hty9FPZPOVhZlyCESEhLS2fD9l9p264db739HvJKajhMwdZFi7EZuXyz4gNksiHAZGTyKL784H2Kiopssh6II4qgpVJ/CObwX0ocV6NP2H9zAmHL+QfxF04XpxsMf/1y0m4Rf+G0YGtKiAez/sKlpaWhVCoJCgrSOR4UFERSUpLea27cuMHmzZtRKpXs2rWLBQsW8MEHH7BkyRKD6yxbtgxfX9+Sj/r161e6t+xCTU1CZb4D2vOsRRtNWFT8+SL0RxW0JOSa5qegPc8SLC1iTM6+o7OH8ujzenBIykEEIiEzM4v+wx5ly88/g0yYFz9bi4SE7Dz++GULt+Ovo1YvBECtWkiCDaMKYogilMVUf4jsNPv4QwiFveYf3MlILf6f8a9f6XkSroTNBy6pVCoCAwNZtWoVnTp1YtSoUcybN48vvvjC4DVz5swhKyur5CM+vnIjKJ/iP/7nDTx+vtx51lA2mtCx+FgnjEcVQmuU+ikY219ojRoo8tLsFk3wdC8kyKe6SXsr7/VgaTTBWUVCTk4Og0Y8TkhICKu+WWNyl4sxbCkSErLzSMjOo6ioqEw0ofQn1hZRBW0UQSwCATSdDJly7ZwM4z/lPrVt6w8hFPaenljdX2uLbvzrV3qehCthllCoXbs2CoWC5ORknePJyckEB+u3zg0JCaF58+Y6Q1BatmxJUlISBQX6izg8PT3x8fHR+aiMMJ8Aant48Rb6fQeWAnU8NK2SleEVG0tgC8Njd8tHE7QsojSqUN5a+tGw5ngiM7o/T2Q8Gta80v0Jzf2R3Sr1bCjr9WBpNMHa6YuOFAkAP+/6gxo1arL2h/V4eFj/h9nWIgE0bY9//bpVJ5qgReiogljSDGXRtjt26BKBX2B9MPJTXiuwAc3Cu9h5h+bhqPHK9Vt1pGZAKMa+fjVr16N+q44VL5ZweswSCh4eHnTq1Im9e/eWHFOpVOzdu5eICP1Denr06MG1a9dQlXmXfeXKFUJCQgT5Y6tFLpMxrFEbfgWGous7MBQ0xxu1sXqegjaa0B9oDeSX+WgD9Kc4qqBW60xk9JC78Vjzluw0sL+dwGPNW+qdp2AK7uRYFE0A0zwbyns9WBJNAMtTDtaOZ7ZGJOTl5XEx9jaPjxzJ5m2/4OVlfVTKXiKhqKiILz94H5lsAPp+YmXyAVZHFcQaRTifmF0yclmuUDBqxlww8lM+csYc0c4DcLT/glyhoM/kVzD29evzzP9E+/WTsA6zX5VmzpzJ+PHj6dy5M127dmXFihXcuXOHiRMnAjBu3DhCQ0NZtmwZANOmTeOTTz7hpZde4oUXXuDq1assXbqUF198UdhnArT3r8uk5p3ZFnOeyDJzFOp4eDFJoDkKF7LSSci7SwJg8OUi7w7n72TzQLnD2jkJm69cZGeZ1jRPZDxZPEfBmrSDJbgHadpUtZ4N89dsJbLMHIWGAX6sHV86R8GaaII1KQdLsda/oaCggMfGTsDDw4Mf1m9CiD+D9hIJAGdPHOV2/HXgOvp+YtUqSIjTnNc5oqfZ64ktimBsYFKHXv2ZuvQzNq5YSmZKZMnxWoENGDnjMzr06m+3fZqC2KYn3hfZh+GvLS+eo1D69atZux59nlkuzVFwYcwWCqNGjSI1NZXXX3+dpKQk2rdvz2+//VZS4BgXF6dTBV6/fn327NnDyy+/TLt27QgNDeWll17i1VdftWrj1cKakHjxGiEtdVME7f3r0q5WiM0mM7bw9Wd2624UGpmZ4C6X09LAei+Ed2Jq23CTJjOaiiVFjNpoQlm0ng1HLl43OpnR3GiCxSkHgeoSLKWoqIgxT08hOTmZ7Tt3W3UvLbYSCVqBALpTFtt17MLbn6+moCDf4LUeHp6062heyN2ZBEJZOvTqT/j9fbkafYLstBR8agfSLLyLqN4Ji00glOW+yD4069ZbmsxYxbDo1Wn69OlMnz5d72P79u2rcCwiIoKjR49aspRFyGUymvvWtsm93eUKegbWq/Q8j3I1CjqPyd0Y3byVkNuyaBKjNppQFoVcTs/WzfSfb2E7JFiQchBB8eI7H33G1atX+XX37/j5+Vl8Hy22mpFgbAyzh6cnfQYPE3Q9sYoEU4clyRUK7uvY3ZZbsggxC4SyyBUKGrYVdy2HhLC4pNeDoylfyGgqlqQdhIomVLqOvVMOOE4kqFQqsotkTJn6LGOfmoB/QOUFsMawZ6rBlji7QBArziIQnIXT1zMoyrvj6G24FJJQsAKlWs2FzDQyCvLw9/CilV9tFMUpB2utpSuspVJxKiGR1Dt3qVO9Gp1CQ0pSAoaiCUqViqPXYtlx7hJRbVvQPaxhyTX6ogmVYe+UgyVYKxLUajUvzJqLSqXigxUfUb1G5R03xpBEgvC4inGTIYGgUiqJ+/cUCRfPENqyAw1ad7JZaN9VDJ5OX8/Q+TzE1/qCY4lSJKFgIYdTE1hzNZqk/Hslx4I9vZnQLJzeAkzqK8sf127w3r6D3MotVcn1alRnVq+eDAzT37e8+9wl3tz2B/FZmojDj0fOUN+3JosffYjB4ea1YFoSTbB4+qIAjpDWiIRXFixm165f2bXH+rn1tq5HsKdAAMeLBFcXCGBf0yVnN3gqLw5C/Uq9VgruWT64TqIiNh+45IocTk3gnfNH6Zx/T6dJqHP+Pd45f5SDWeaPiTaUdvjj2g1m7NxDh9w7Omt1yL3DjJ172HMtrsI1u89dYuraLbTJysGz+JgX0CYrh0nfbue3WPN9JCypTXBEysGamoS3ln/ETxs38svO3TRs2NDi+4BriQQxtD2WTTM4q0iobIJiqelSe0AbJWxITnp7wU2XnNXg6fT1jJIP0IgD7YeE7ZCEgpko1WrWXI02aj719e2bKNXGnSRNWkul4r19B42aNb178KzOJEilSsWb2/5gMFAPTbf8KiAPqE/lBk/lsSaaYDZWzEuwtsPhjtqNvo/0Y9uOXTQNMzxsyxRcTSQ4kvLzEJwNfSOW9aFruvQ4EIfmNzcWGImQpkvOZvAkiQPH49SpB0MtkrbkQmYaSfn3jJo7RRYWcDY1hU6B+qdVmsqphERu5d7hJwNrzQEiM7M5fiOeiDDNO+DjN+KJz8rhO2AAmj8Fk9GImO/RDJ56qNjgyVB3gxatSDAnmmBtysESrKlLUKlUvDJ/Ea1bt2H02HEW70GLLUSCodZHWyAmgaDFWQWCFlMKFEtNlzYATwMa8y7YAbwFfE1O2gPEXzhtdcdB6VqbMWzwFCnIWpZiLK0gYX+cWijYgsrGN2cUmGY+lZ53z8AZFTGUdki9c9ektZJzSvNx2v9/hyaKsLj4+GI0IuGH4s/LGjwZ3Zs9Ug5W1CVYIxIKCgqYOO1Fjh8/xsRJU8y+vixagQC2EQn2EgjgWJFQ1QSCllIzpYvAVTSCAWAh0Bm4VO48yxGrwZMkDsSLJBTMxN+j1HxKXye21jIlwMv6H/I61auZtFZQzdKwu/b/69BEE8qaVg0qPg4VDZ7KY2nKwZ51CdaIBKVSydCRT5Kalsrve/8iKMjy6I+zpxrEEEWoqgJBS6mZ0hI00YSyv7lRxceFMV3SNXgy/JfFHgZPziwO1ColRWm3rb9PoX7PIzEhCQUzaeVXm2BPb97Kv8d2dAN3WnOnUO9qtK9j2jtxRZ7hwsJOoSHUq1Gdpbl32KZnrWVAAz8fujYpteHu2qQ+1d3duVNYWBJN0KKNKtTw9CgxeDK6NwtSDmZjYV2CNSJBrVaTJ/dk7LhxPNy3n0mmY4awZaqhKkQRnFkgCDn/oH6rjnjVqEVebhywtdyjmqiCV41agpguaQ2ectKXgoG/LLY0eHJmcVBVkYoZzUQhkzGhWbhR86np7bugkJn+pTU0ZEkhlzOrV0+jZk3zh/bRGbFcWKSiqKiIfug3reoHFBYUUmjEBMjcCYz2rkuwRiRcv3GTnn36c/v2bYY/+niVFwmO7Ghw1k4G2xg0qZEr3MHIb67czQPKeMRYiiMMnqSCROdGiihYQGSdUF5t0501V6OJLDNHIcTdg6WdI+htwThlQ/QNa8KKwf14b99BIsvMUWjg58OXQ/swoG0LnfN/OHKafLWaPRgxrVKrWf3HYaYN6lXhIUsnMNqrLsEakXDmbDSDRzzO4yNHElK38jHcxnBWkSCmNIMziQOw7QTF+AtnuJuVAkZ+c+9mas4TosDQHgZPUuTAdZCEgoVE1gmlW+26OpMZOygL8TdDJBhLO5Slb1gTHmrSiFMJiWTcSadeo0Z0bVK/glkTwMhu7UjIyiavoBA1atJyc8hDjreHB0G1fJDLZHh7ePBkb8Oz7s2NJjiDSLh0+Qr9oobz0sszePl/s82+vixCi4SqUovgrGkGe4xYDm0RzrDZ71NUWIBapSb9dgz5udl41vAhoG4jZHIZbu4ehLYIF2xNWxg8SeLANZGEQhm8YmPNOl8hk9G2lqbgxzM9EV8j3RKGMNXbQSGX06O+D171DFUqa/Dx8mLhEM27AU/3QrNGNZsbTbC4LgH7igSAOg2a8OHKlQx/9HGLrtcitLFTVYgiSAKhctzcPWjRs59N19CHEAZPkjhwfZxKKMTkpNPcN6hSy2iVWm2xzbSx1khHolSpOHUrkehLcXRpWI9uTRvojSiUv+bYv1eNWkZrKTszQa1Wc+rSdTq1aIqskq+bJdEEe4qEmzGxLH77PR57fCRKpYq/DxwgskcPFGa+azI1iqBUKjl2+CAnjx+lc9fudIvsaXAtrUhQyODkkYOkJSdROyiYDl0jzN6fIcqKBKVSyb+njvJfagq16gTSulN3wdYpj3atf67EUjOgDh26RDiFh4DQ4sBSLwW1Wk3StX8JDmtd6e+gI5DEQdXCqYTC99dPEuDuRb/6rWldK0TvOWczbrMt5jxpBaVDamp7eDGsURva+9e111YrxdS0A2i9Hv7mVm5plXp935osGNa3Qo1CyTUX/mXRtv3EZWSWHGvg78eSCcOJ6qo/fKlNOaz//W8mvfUp386fzuhH7td/rhUpB3OwRiQk3L5Nz4f6cvduHut+/LHkeN3Qhrz97tsMGTrMpPuYKhJ279jO4rlzSbxdGpkKqduQhUuXMiBqqO7eikXCwT928f7C+aQklo7iDgxpwCuLl/DQgCiT9qeP8lGEw7//yqpli0lLKl2ndnADpsxZSOQjgyxeRx+Hf/+VT5csJCv1Vskxv8D6jJoxlw69+gu6llDYInpgjZfCv/t2svPDuQx+eSltelv+cyAkkjioujhV18OfQERhHutvnOLf/ypaOZ/NuM03V07SvSBPp463e0Ee31w5ydkM63te9WGprbQpaQet10N47t0y09+hXVYOU9duYfe5SxWu2X3uEpO+3U54RqbO1yE8I5Pxy1ez43i0zvllUw5FRUqWffsTAMu+3URRUcUxrhalHCyoS7BGJKSkphLZuy+pqancufMgZSu7E2+3Y/zYMfyyfVul9zFHJEybOJbE220oO6c/8XYbpk0cy+4d2wGNQEjIzsPDTcHBP3Yxe+p4UhLDdfaXkhTO7Knj+b/dO8x+3qBfJCyd8QxpSbrrpCWHs3TGMxz+/VeL1tHHho0/sfSlZ8hK7aCzVmZKe76c+xxn9v0m2FpCYJsOBuu8FFTKIv5e9yUAB9etQqU03KFkD6RuBQmnEgpdKPVT2BP/Lyp1aauQSq1mW8x5ox4M22PO61wjJELbSoOu14P+6e+wZPufFbwelmz/3ag/hD6vB200YdPeQ1xLTGEVcPV2Cj/932G9ezMrmmDF5EVLaxLiUzPJzspB84x1fyLU6m3AYOa8OgelkXn25qQbFs+di1pt+Du1eN484v7TdK14uGnSAO8vnA9qPd+p4v19sGiB0f2V50bGXW5k3NVpeVQqlaxattjoOquWLTZrHX2cT8zmn1v/sePTdzDmIbBpxTJReAjYSiCA9V4KFw7sJis5FlhFZnIMFw7sFmxvplK2nVESBxJOJRSg1E8hvTCPmNxSl8Zr2emkFeQZ9WBILcjjWrb5zo5CY2hkc3m0Xg+z0Ux7105/jyr+fBYQV+z1oOVM3E3iMnOZi2F/iNhirwfQnZmgjSYMkck068hkFaIKlk5ftKQuwRKRkJOTww8//0JaWhp37uSAgZ8ItXoOCbdiOHzokN77mNPZcPzIoeJ0g/7vlFo9i8SEGKJPHCkpWjxz/EhxusHAd0o9h+TbsZw5fsSk522oYPHfU0eL0w2G10lLiuPfU0dNWqc8WtMmgNTLZ4vTDYZ/+v5LieNq9AmL1hICWwoELaVeCoa/Djlpt4i/cLrCtSXRBFkUMBlkg+0WVZDEgYQhnKpGQYu27j+nMB/t4N3sQtM8GLTnOQNarwfj09/LeT1ka961VvZ1SMrMrtDloI0mbNSuo1bTuTiqMPqR+y1OOVhavGgud+/eZcjIMXi4ezD6ybHFR41/JZKTKqaNzG1/TElOKv6f8e9UZlrp7Py0kmuM76/0PP1UNl3xv9QUk9YpPc90ys9DuJpm2lrZaeavZS1lxYGtscZLoTSasEVzQL2IzOTOXDiw2ya1CmXrDiRRIGEIp4soQKnHQU13z5JjPu5eOo8ZusbHwLvUysygDOGZnmhW2sGcIkat14Px6e+l/g6e7oUE+WjC/JV9HbReD/qiCTrrlIsqWJJyMAdL6xLy8/N59MkJKJVKftiwiZC62rZQ41+JoGDdolhLZiQElvhEGP9O1S7jJ1H6f+P7q23Eg8KU6Yq1SkaJG1+nlokjx8Gw9bNPbdPWKj3Ptphq8Sw0ul4K+tDvpaAbTSjzMyRwVEGKHEiYi9MJBa2fQoC7F41qBJQcD/MJoLaHF28Vn6PvmjoemlZJR2Pq7ITuoTWo5elBHJr3pmVZiCYTHlDNS8fr4f7IbjTw92Mp+r8Oy4CGAX480L65zmAlbTRhYbkajoVqNVdvp7D5wAmb1yVYU7y4e98hMv/7j00/b6N69epE9uhB3dCGyGT6vxIy2TJC6zUiskePkqOWDlLqGtEDX78AMPKd8vELoEPXiJKjHbpGEBjSAAzsD9kyguo21LlGi7YWASqfjdC6U3dqBxtfp3ZwA1p3MjyAS0vZNIO+eQjNwrvgF1gfjPz01QpsQLNw21oX2yO9YAytl4Kxr4M+L4WSaIJ6ke4l6kVW1ypI4kDCGpxKKByn1E+hX/3WOrMR5DIZwxq1MerBMLRRG5PnKYgBNeDp7mbUt8FDLket1kQTQDOYacmE4Ub9IZY+8ygKRem3XhtNGCCT6V1ngEzG0q/WUWTEH0IHOxYvqlQqLsbepu8jj7Bn718l3g0KhYK3330b2IlMNoyyXwnN5ztZ9s6ykjkC2kFKlgxTUqvVuLl7YGxOv5ubJ+oyIkyhUPDK4iXATii3P4r3979Fb1aYc2CuR4NCoWDKnIVG15kyZ2Gl8xRM8WWQKxSMmjEXYx4CI2fMsdk8BUcLBC2WeCmURhP6o/dnSNbf7KiCJA4khMKphEJf4Ii7F6ObdNI7R6G9f10mNe/MUQ8vIgEfIBI45uHFpOadBZ+jYG5bpDlpB4BTCSkk5d4tmf5e/mMPkJh7lxM3NcWM2imMUV3DWTtzItH+fjpfh38C/Fg7cyJDI9rrRBMOn7vEtcQUdqvVetfZrVZzNSGZQ6fPmbx3exQvqtVqps54hcmTngaZAjc33ZKbIUOHsfaHdYTU/QfKfCXqhp5j7Q/rGDJ0GBn3iqyetnji6GHSUxPByHcqI+02Z0/oFgw+NCCKd79cS2BwtM7+gkL+4d0v1+rMUTAnilCeyEcGMXfF19QO0l2ndlA0c1d8bXSOQmVRhPJ06NWfqUs/wy/wrM5atQKjmbr0M5vMURCLQCiL1kuhZsBpyn4datY+w/DXKnopxF84UxxN+A29P0Pq38hMjiH+whmj6xoyX5KQsAaZWm2jfkEByc7OxtfXl6eadq4wmfHutRuEtNStLbBkMqMlNQqW1CeYmnZwJ4f8IiV/Z+VRUKREpVZxPSWD7Lw8fLy8aBroj1wmx8NNweD2jfB0c6swrlmpUnHk4nWdyYxe1TR/7MsKhfyCQnYeOklBYcV3KzI3d2Re1fH08CDqoR54elTyR9hOkxfVajUvz1nAjh072P37n9SrV9/guUqlksOHDpGclEhQcEjJZEahPBvy8/PZtGUbBQX5yGUQe/0aOdlZ1PTxpWHTMORyOR4enjzQdwAenp4VrlcqlZw5fsTgZEahRjCbM5nR2rHLKqWSq9EnyE5Lwad2IM3CuwgeSbDniGVLMXUyY1FhAdeO/UVRYYHBe7m5exDWrXdx9KoUaRBSRQru5fLjcw+RlZVllUOsIQ4ePMiYx4Zz5adPrb5X3xcWMfWVuYwdO7bykx2EU3U9NKpp2ihmuUxGc9/adtiRbfFt1JjBJpzn6abf00Ehl9OzdbOKx8uZPnl6uPNo74q5cLPto+1YvPjt+s1s+flndv++16hIAE34/f4HHtA5JqSxU1q+mocGDbXYr0GhUNA5omeF45V1NFiyTruuPSo9Twh3R7lCwX0dK697sARnEAhaTPVSMNfrQRIHjketVJJ327Jhe2VRFRgWh2LBqYRCee5eu6H3uLkRBUujCeZgbjTB5H0U1yaYdF8zTJ8sFQm2Ll7Mz88ns0DNsOHD6XH/AzRo0NDka7UIJRIMGTqp1WouRJ+hVXgHk+f0l7/GEUZOhgSCJdEBW1wjlECw1H/BUoT0bZDaGSUcgVMLBaBC2sGeXg+2mMaoxcsMu2pTHCLLmj6ZithEQlZWFiPGjKNdu3a89fZ7NGhg/rwFW4sEgF1bNrJwxjTeWPkFA0eMMul+2mumv/URDwx+FLCfSDCWZjiz7zc2rlhKZkrpUK/KfBuEvKbTmBdp1PUhQJjogTX+C5ZirW+DJA4kHI1TFTNWhqO8HirDnCJGc6MJ5thImyoSzJq+aCeRcDsxkV79B+Pp6cWc+eVbECunbNGiLUVCUVERX37wPgBffvC+SZ0iZa/Z9PlKPOVqu4iE8oWK+kTCl3OfIzOlPab6Ngh9zd4Vs8n454BgIsFS/wVLsdS3QepYkBATLiMU7On1YIkJlKlpBzAtmmDrlIM52FokqNVqnhg/ifDwcNZv2kyNGuZFEoSMIhgTCQB7tm/mdvx1YBUJcdf4/ZefK73vDz+uK7km5dZ1DuzaZtU+K6MygQCa8PzGFUsxx7fBVtcY80UwFWv9FyzFHN8GSRxIiBWXEQqWej14xcZiCbZIO5gTTQDhUw6W1CXYWiTE37rFXdxZ8933fPrFV7i7m1dgZ4tUgyGRoI0MyGQarweZPKrSqMLVlGw2fb6y9BpZFD9+8iFKU2dWmIEpAqFkX9EnitMApvs22OoaQ74I5mCN/4KlmOLbIIkDCWfAZYSCNV4PloxuNhVzihhB+GgC2LYuwVQsEQk7ft1FeJcILly4QHBIqNmFYPaoRyiLNpqgVmtSI2rVQoNRBe1chEO7t5GScKP0GvVCkuKFjyqYKhC0ZFvg22DJNWcu3dB5zNA1+nwRzMEa/wVLqTBpsXjC4q7Nm6VZBxJOhcsIBWu9HkzFkrSDKdgymmAKtqxLsEQkfPfjesZNmsJnX35F6zbtTL5Oi71Fgm40oXROv76ograjwVOu5qcvVla8RsCogiFfhsqwxLfBnGu0Q5JCQkJMuqa8L4K5WOq/YCnGfBuu//Y9ITXdJYEg4TS4jFCwp9eDqWkHcycxmhpNELqA0ay6BAvHM5sjEmLj4nh59mus3/QzQ4YOM2sdEEYkaOsRjKUaylI+mqClbFSh/HTF/b9uJfnWjYrXCBBVMHeiYnks8W0w5ZrqAaFk+jUtmaBoqS+CudhrHS3GfBvupcdx89gfgqwjIWEPnFYolJ/IaInXg6X1CeZgStrB1GiCuQWMNqlLwPziRXNEwr1796hdvwmnz57jgQcfNPk6LUKJBKg8iqClNJowAH1z+mXyAXzy3nsoi4pKPBqURUX8+MmHhq+RDbAoqmBOHYIxLPFtMOWaRya/QpCPt8415voiWPp87LEOwMkrKexd+zlg2LfhzLZvBXODlJCwNU4rFPRhideDOfUJ5oxstkU0AYRPOYBt6xLMEQkHDh6iZYcuZGXnUifQfCtiR4gEgLMnjhZHE3ajb06/WrWblFvXuXn+ZMk1/54+VhxNMHCNejdJ8df59/Qxk/chhEAoiyW+DYauMeRxAOb7IliKLdcpW5TolnqFexnxgGHfhpzUWJKvRlv/pCQk7IDTD1wqT3v/urSrFWK214MtcFQ0AUxPOdiyLsEckXDq9BmGjxrD0rffxc/Pz+TrwHECQUu7jl14+/PVFBTk6xxPydWMZvV0k+Pu4UHL9p1LHmvZvjOvfbiKQiPjW8tfYwhrfRmM0aFXf8Lv72vWlMWiRl0Zvvxnki+dwe1epknTD++L7EOzbr1tPjFRyHUMDUJSVm9Lr+eWoio0/Dsrd3cnsGlbs9eUkHAELicUwPm8HhwRTbBlXYK2eNFUbtyMYdDwx5gzZy5PjRtv1rWOFgkAHp6e9Bk8rORzbR1CCwxPV3T38KRn/yEWrafFlgKhLKb6NpQdsRzk401Q10iz1zHFF8FarFnHFI8FhbsHjbvYZsqjhIQjcEmhYArm1ifYIu0gdDTB1JkJtqxLsKTDwT+0ISs//piooSNMvgbEIRLKYy+PBiGMm4TCmUyaLEEyYJKo6lRZoQC2nZ9g6uwEIaMJYPrMBFsMVTJXJCTcvs3sBW/w4cqVdhcJWoEAwogEa5weCwoK2LV+NUnxsQTXb8jA0RPxMGDn7SwCoaiggNO7N5KZGI9fSH06DhiFW2UW5SJCnzhQqZQkXznLjUtpePvVJqh5e+Ry+5l2GUO7t3uZ4tubhPNjkVD49NNPee+990hKSiI8PJyPP/6Yrl27Vnrdhg0bGD16NEOHDmXbtm2WLO0QzJmdYItogtApB1sUL5orElJT0+gXNZzuERFUr2GeX7xQIkEMUYRv33uDbWu+QaUqrW/49t2lDJswiadnvV5yzF5pBlPQCgRD0YP/W72cE9vXoS7znP5avZIuQ8fw0MSZdtmjpRiqO4g5+RfH1q3k7n+lfjHVatWl25iXaNS5t133WB4x703CNTBbKGzcuJGZM2fyxRdf0K1bN1asWEG/fv24fPkygUYq1WNiYnjllVe4//77rdowGLaXtiXmjGwWKppgq5SDSZhRl2CuSMjMzGLA8Mdo3aYtH370qVkTF11NJGz59jM0/gPz0EwHPI9K9Vbxceg6dkbJ+WIRCGBcJBzfupryz0mteqv4OKITC5W5M8ac/Iu/Pn0NzXP6Ge1zuvvfW/z16Wv0fv5th70gi3lvro66SEnurZTKT6wEZb7hgmaxYHZ75PLly5k8eTITJ06kVatWfPHFF1SrVo1vv/3W4DVKpZInn3ySxYsX06RJE6s2rKW8vbQ52GN+gjHMmcLokJSDDUUCQGLWHTp17syXX3+LwoxqczGJBO3wJO1cBHMpKChg25pv0PyB12djNpita76hqKBAsHZHS9FOUQRKBiXpo6iggBPb12HsOZ3Yvo4iI50e9sJUjwWVSsmxdSvRbyalsZs7vv4jVCphzaRMQcx7k3AtzBIKBQUFnDp1ij59Sit65XI5ffr04ciRIwave+ONNwgMDGTSpEkmrZOfn092drbOh9CYWp9gi7QDCB9NqAyzUg6YN1TJVJGQn5/Pmo1bqF+/Ph+u/MRgHl4fQogEU6csVoYQBYu71q8uTjcYtjFTq/I5u2ujxWtYi6kCQcvp3RuL0w3Gn9Pp3Y55TmXFAZjmsZB85WxxSN+QmdRc7mQkkHzlrA12bBwx781R/HMljX+upPHvtYzKT5YwGbNSD2lpaSiVSoKCgnSOBwUFcenSJb3XHDx4kG+++YazZ8+avM6yZctYvHixOVuzKUKmHRwRTTA35WCLWQn5+fmMnjiZ2wm3GTJsBF4K098hZ9wrEkUUAYTrakiK10a1jJsUpSXYP/plaRdDZmJ88f+MP6fS82yPtR0L9zK14t/4cyo9z36IeW/24p8rFZ9bo4BqFOapOWv/7bgsNu16yMnJ4amnnuKrr76idm3T5xrMmTOHmTNL85jZ2dnUr19fkD3ZKu3gqGiCLVIOpmDOrISsrCwefXI82dnZbNm2Ay8v08SF2FINIFzbY3D9hsX/O48mVFwejUlR7dCGeh6zDda2OfqFaH9HjT+n0vNsR2V1B6bi7af9u2X8OZWeZz/EvDdbYEgUSNges4RC7dq1USgUJCcn6xxPTk4mODi4wvnXr18nJiaGqKiokmMqlcaQxc3NjcuXL9O0acV3656ennh6eurdgxCFjLZIO4B9owmCpxxsWJew//gZvL29WbdxMzVqmCYwXFkkAAwcPZFv312KSvUWmnxy2dCxxsZMJvek14ixgq2pDyFnIHQcMIq/Vq9EXclz6jhglFXrGEIocVCWoObtqVarLnf/M/ycqvuHEtS8vSDrucrerEUSBeLCrBoFDw8POnXqxN69e0uOqVQq9u7dS0RERIXzW7Rowblz5zh79mzJx5AhQ+jduzdnz561OEpgaSGjJdEEU9IO9o4mCN7lYCORcOHSJfYeOcHDffqw4actdhEJWtdHsF4kWFuwaIwr6Xn0fGwsGpMifTZmO+nzxHibzR4wt/7AFNw8POgydAzGnlOXoWMEfU6W1B2Yg1yuoNuYl8CI3VzX0S86ZGaBmPdmDtq6grIfoBEGZT8kHIfZqYeZM2cyfvx4OnfuTNeuXVmxYgV37txh4sSJAIwbN47Q0FCWLVuGl5cXbdro5s+0c/zLH7cXYo4maEWCKbUJgk1ftJFIOHjoMMOfeJKXZswgItL0llhrRQKIN4qgRTsTYcyM+Xi6Kfhzw1rUqp0lj8vknvR5YgqPTp8j+Nq2nqKobX3UzFHQfU5dhk4UrDXSFtEDQzTq3Jvez79dPKugdCx1df9Quo52bPuhmPdmCCla4HyYLRRGjRpFamoqr7/+OklJSbRv357ffvutpMAxLi4Oudw1TCntHU0A01IOgtUl2Egk/LxtO5OmPsdby5YxcdKUyjdajBhEgj0EQtlWx0enz2HolP+xb8sPpCXEUju0Ib1GjBU8kmDPMcsPTZzJA09OF3wyoz3FQXkade5Ng44PiHL6oZj3JokC18CiYsbp06czffp0vY/t27fP6LVr1qyxZEkA7t2IoVGr+yy61is21mYjm02JJgiZcqgMk+oSbCQS7qjd+HP/Ib5Z8x0DBg6qfLOIox7BmhHMlVHZVEU3Dw/6PPG0oGtqcZQPg5uHB12HPmX1fcTksyCXKwhp0clh6xtDDHvTJwpAEgauQJX2ejCEqQZQpkQThCpgFLQuwQYiQaVS8f6nXzJ27FN8sOKjyveAZhDXnr8OkJKcRHBwMF0jepg1gEmsUQS1Ws3V82fJD2hSMnVS6IFJKqWSK2ePc+OfkzRp15nm7bvqWCULLRDUajVJ1/4lOKy1WZM0LUFM4kDCMFK0oOpQJYSCLScxmjKu2ZRogt3qEmwgEgoKCpg47UVOHD/O4CHD8fOvvB3rl+3bmD3rNZJul35vQuo2ZOHSpQyIGlrp9WKOIvz1y2aWv/YCo+a8R++oxwS7r5Yz+35j44qlZKaUziPwC6zPqBlzKWpU6rkiZATh33072fnhXAa/vJQ2vaMqv8ACHJlakDCOJAqqNq5RTGACQhcxChVNEDLlAKbNSxBSJBQVFfHEhGe4cuUyv+/9i0aNGlV671+2b2P82DEk3W5H2UrtpMR2TJs4lt07thu9XkiRIHRHQ/StDFav/ACAvWs/R1lUJNi9QSMSvpz7HJkp7QCtAG1IZko7vpz7HBn/HBCsi0GLSlnE3+u+BODgulWolMI9J1NHKUvYF6kLQaIsThVRCGpuvk+ErVoiQZhoAgiXcjC1LqEyzKlJuJWRg1wuZ9svv1LLv3KRolQqmT3rNdRq7Xx6rVbtjlq9DZlsGIvnzeORgYMrpCHEHEXQ1iFE793Jf4kxwCrSbk/h5J876NZ/uCBrqJRKNq5Yima2/6No2uJWAVOANwA5f379Ac269dZJQ1jLhQO7yUqOBVaRmTyFCwd2WxVVkFIL4kKKFkhUhlMJBUtx5mgC2L8uASoXCWq1mq2/7eWRfv347scNJt0TYM9fB4rTDRvQN59erZ5DYkIkx48cIqLnAyWPCB1FEIqyhYo13WTs/e5zZLIhqNWTkcl2sOPrT+jcJwqFm/W/alejTxSnG9YBTwNDgMnADuAt4Gty0h4g/sJpGrbtYvV6UCaaIIsC9WSQ/cLBdato9cAA5ArznpOUWnA8UsGhhCW4tFBwhWiCI+oSTIkkLFz2PmtWf8vBI8epXadOpeeDprshJTmp+DPj8+lLzxO/SNAWKh7dvYX02zeBzQCo1QtJu91ZsKjCmUvaqaQXgatoxBbAQqAzoPFbuZORavVaWkqjCVs0B9SLyEzubHJUQRIHjkWKFkgIgUsLBTA9mmAqirw0wYYrmZJyMAUh6xJMEQkffLqKL7/4nF17/jRLJABlRn0bn08fGBQseoEApSJBWVTEjm8+KY4mdCx+tBMyWZTVUQVtB0O1kpn9S9BEE0rXgaji41Dd37TvSWXoRhPKrCUbbDSqIKUWHIMkCiRshcsLBVMxtSXSVIxFE4RMOZhSlyCkSIi/dYv333uXzVu307JVq0rPLz8joWtED0LqNiQpcSlq9TbKz6eXyZYRXLcRoa01PeFiFQnl2x1P/PGLTjRBizVRhfItjgGduvF/NWqRlxsHbC13tiaq4FWjFvVbdUQIKkQTtBiIKkjRA/siCQPHolKqyLn1n9X3UeYLW/BsC1xWKNhiwJKp0QR7phyMYmbxYmVkZ2fjH9qIM+cu4OPjU+n5+gYpKRQKFi5dyrSJY5HJhqFWz0GTbjiPTLYM2MkL81ejUChEJRIMCQQoG00YgFrdGsgv82gbZLIBZkUVDM9AUCNXuAP9gIrrQD/kbmcBtalPyyCl0YT+oOc5IevPwXWryAvtVhJVkMSB7ZBEgYQjcVmhYA7m+joYQogCRlNSDkLWJZja4fB/+/YzduIzHD91Fv+AgEr3aGza4oCooXy++gcWz51L4u3S+fTBdRvxwvzV9Oo/2GKRYCuBAIaHJl3752RxNOEmUPHrqFZD2m3Nefd11Jdu0VDZkKT4C2e4m5UC7NG7DsDdTM151hYzxl84UxxNiNW/lhoykyHz5jnado6s+LiExUgFhxJiwyWFgi2KGE2JJoBpKYfKhiuZ4uUgRF2CqSLh+ImTPD7mKd794EOrRYKWAVFDeWTgYI4fOURKchKBQcGEtu5kVSTBnlGEsjRp04HJSz6hqKDA4DluHh40adPB4ONlnRwNEdoinGGz36eosAC1Sk367Rjyc7PxrOFDQN1GyOQy3Nw9CG0RbnS/plB2LS0xKXdK/u9fzQO5uzsNwjtbvVZVR4oWSIgdlxQKYDuXSEOYOqrZ2gJGoeoSTBUJcfHxRD06knnzFzB6zJOV7s8c3waFQlHSApmQnWe1QABhRIIpUYSyuHt40ukh03wtymOKQNDi5u5Bi579LFrHXLRrla076NJOSi0IgSQMJJwNlxMKYo8mGMKUwUpC1SWYM1CpVt2GfPXNt/R5pH+l51pi7mRtZ4Otogg+7nKuRp/galoKPrUDaRbeRdAhRmUFgkqpJPbcCe5kpFLdvw71W3WsdC2VUkn8hdNmXWMOUmGiMEiiQMIVcDmhAMK2RApp/GRNykGougRTRcK/Fy8yZ+GbfLHqqyohEsqmGYx5KXToVfnXwhjl6xAuH/6TP796n5z0hJLjNQNC6TP5Fe6L7KP3HpZcYwqSOLAeSRhIuCIu5fVgbjTB1JZIIaIJ1qQc7C0S9v99kF6PDCQ8vD2+fsbTHBn3isi4V4RCLrObSLiRcZcbGXcF8Wk4n5hdQSRovBTaU9aHIjOlPV/OfY4z+36zaJ0TMRk6UQStSNj69kxy0jvqrJWT3pGtb8/k8uE/K9zHkmuMUdZrAZC8FsxE8kSQqAq4XERByNoEU6MJtkw52Fsk7Pnj/9s787iqyq2Pf+EwaSJCzIoajmkKJmJi5ZBTmjcabr5aapZZqU3W7eKQyC3Ryny9r9csh9K6mkMlt5zN4aqplQJmiVOGmAlIiBAiwzn7/eNwgMMZOPucfSZ8vp8Pnw/s/ez9rGejZ/9Yaz1rfcOoJ8Yz/933GDf+SbNjbfEigPUiAWz3IhjLQ9DvpZBG3T4U2p8T2bBoHjH3DLbYzW8qB0GjVvPN8gVm56rft8Gaa0whvAfyEd4Cwc1KoxEK1tRNsNWb0FDIwdZdDo4UCZIk8adGRaeYnqxdv5H+AwaatdnRoQZ7CgQdtb0UNmCsDwVM52p+AmeP/2B2myM0nKR48WR6dejgc5NzlRQk6PVtsOaaughxIA8hDAQCLY1CKFgTcmgIJRIYwfbCSo4QCWq1mhdfn0lAQACzklMIDYswa5MjRYKSOxoa2u5YXJBf/Z35PhS14/RpqA5CXWr7MZifq27fBmuuASEQLEUIA4HAOI1CKID8kIM5b4JSIQcl8hIawpLyzOZEQllZGY8//SynT51i46avGryXXJFgS6hBaS9CQ1sdmwfrRJv5PhS147TIEQg6avsxmJ+rbt8GOdcIcdAwQhgIBJbh9kLBXh0ilQg5mLxeobwES2olNBRuSBz1BNfLrrPjm70NFlOyViQ4y4sgtx5Ch5hetAiNoig/Ff0cAAANMI/A0NZ0iNG69a0RCDqiutyJ/60tKfnD9Fz+wa30+jY0fE0qvi0iKfBriwdCIBijvjgQwkAgaJhGsevB0QmMYDrk4Ki8BFtFwo0bN7iONzPfeIO0r7e6nEiwdUdDXS+CJSIBwFOlYtTLM4DNQCJ1dxVof97MYy9P59jFawY7GOTiqVIx6JnXzM41aOKrekmJ5q95ENhCwuMv0SqomRAJ1dTflSB2JAgE8nFrj4Icb4IlIQcdDXkTXCEvwRwNiYRj6Rk8MmYsaV99RVy8+aQ8oGb7oyU4O9Qg14tQnx79h/Fs6vvVdRRqexgEhrbmzjHvUNU2HpDvQTBGp4RBPJS0sLomQu1c/sGtGDRxodGaCLprti59h/JrtdfcEtSS+NHzaRs3wGa73BnhMRAIlMethQLIK65kawVGS0IOtuYlKJW8aIp9+w/w8KgxTJ8xk46dzLeJdoYXwRYszUVoiB79hxFzz2DOHv+B4urKjEUt2uHpqVJEINSlU8IgOvQeYHGVxfRfCiHsTu6dvQZV/mnKigpo0iKYsI6xeHoqV5nRXRDCQCCwP24rFORsh7SksJJSIQdTWJqXYBIFdjhkX8jhkf95nPnvvscTY8eZnc6dRIJSAqEunioVne68ix+yCykGwhQWCPXnMtftsW5iItTJPQjqaTebXBUhDAQCx+OWQsGakIMl2DPkADbkJSi0DTI46jY+/3ITvfv0NWunI0SCEgmLtoYZzCGnWZO9EDsXhDAQuC6SWqL40p8230ddrlbAGvvilkIBlA85mEOJkIPVeQkKeRImTnmRTz79t6Iioa5AUKvVHD18kIK8XILDwukR3weVCfe5q3oRoFYg3NpExcWT6Zy0oumSJEnknvuZ8PZd8fCwvNYEmPEe3CRYIwwkSeLqxdMERnWS/bwFAkHDuJ1QkOtNsCR5ERru52BryMEUZvMSFBAJuXl5DB35EIOHDCEgULmdDXVFwp5tX7MgeRb5l3NqzodGtOa1lLcYeP9IvetsFQn2Fgi6HgwbbGi69PO+zWz+3xk88EoqdwwY2eB4uHm9B0p4DHLSd3H0s1R6jZ5B655DlDJNIBBU45bbIy3xJlgacrAkgdHarZA25SUoIBKuXi3i/sRH6RUfz/x33zP715YtIuH1Z8eTfzmGutv18nNjeP3Z8ezZ9jVgeyOn+s2blELXrMmWRk110airOLD2QwAOrl2GRl1ldvzN1pBJ6e2KGnUVJ3d8CsDJHf9u8HkLBAL5uJVHwe/iRUK7dLJ4vL1DDmDfegm25iSUajwZMnQoM2Yl4+lpWhPaEm5YkDwLJCNNiqQ08EjkvTlv0DquP54q6+si2Esg6NDlISjRdOnk/m1cy7sALKMobxIn928z8CrcTN4De+cYXMzcw/XCi8AySgsn8VvmHuFVEAgUxq2EgqW4SsjB1uRFUzQkEsrLy1my8hMmTppEcspbJu9ja9JixveHq8MN6zHapEiaTt7vCWSlf0evvvdYNEddHCUQdNjadKnGm+AxEqRnwOMrDq5dRpd778dT5XVTCARHlkWu9SaMBLTP++SOf9MqdiCeqkb50SYQOAW3+t8U0jG6wTFyQg7mUCLkYA5r8xIaEglqtZonJj7HhQsXeGL8BJp5+xodp8TOhoK83OrvzDcpul5k2dbTuigtEiwpt2xt0yUdtd6EL7UHpDkU5cWx9fPPiYwb0ijFgTP7JdR6E9K0B6Q5lBbGCa+CQKAwbiUUGsLS6os6kWDKm2BLyMGSvAR7iQRJknj2pVfJOnmSbTt306yZ8eJLSm1/DA4Lr/7OfJOiwBDzOz70rnCCQNBhTaMmHfreBF1/hp7g8QAXdv6bngNGyDfeBXGVRkr63gT95y28CgKBsrhlMqM5nB1yABuKKmG9SAA4ce4CP/zwA5u+3sKtwcFGx8jNR7hUfAMfL5XRGgk94vsQGtEaPFLRNiWqiwY85hEc3pquPRsuEw32EwmW9mPQNV0CE+sx0qhJR403QZqjf0KaQ8mVC/z63S5rluAS1E0+BFyiX0KtN2GO/glpDqWFOfyWuccZZgkEjZJGIxRcJeRgS16CtSKhvLycnQeP0K59ew4e/p6WLVsZHWdt0qIpVCoVr6W8BWwGj0T0mhR5JAKbmTQ92WQ9BR1K72jQ7WQAeQWTrGnUBHD0TD67Vy8FhgFdgfI6X3eAxzAy0j5yq4x8c+LA2dR6E0w/b7EDQiBQjkbhm3NEyMGWvAR7ioSrV4t4eMxYqqqq2LZzNyqVce2ntEjQ0bb3fby6YBmr3vkHf+TVNikKDmvNpOkrSBhi3uWutEDQYW1FRUsbNdVNTCz69QRlhReBi4CR35MEJVcg7+xxIjq7Ztlld6qA+MevJ6q9Caafd2mhdlxI+x6ONk8gaHS4vVBQWiSYK9NsTV6CLTscGhIJF3JyGPnIKNredhsrV31qcgukpSJBbudHXfGkAcNHcu/Q4fx87AhXr+QTGBJK1553mfUkuJpAqIu5Rk3Gdi6Ex8TRbHIqmkrTYSlPb29C23Wz2TYlcSdxUJegtl3pPXYOmqoKk2M8vXwIatvVgVYJBI0XtxYKjhIJ5ko0KyESjHkTLMlJ2PCfrST0vZt3Fy4y+VKWKxIs7ddQv8KiSqWie7z58tCgbH8GpQVCXeo3ajK3tVHl7cNtvRqu2Ohs3FUY1Efl5UOrmP7ONkMguGlwW6HgSJFgCmeJhF2799AyuiPPT5mCh6eX0YqLhWVVqNVqjn13iPy8XELDwonv09eooJAjEmwpwayUF8GeAkGHRq0m5+dj/PDtIVrcdgdB7WJoFWS+hbcr0ljEgUAgcB5WCYUlS5bw7rvvkpubS0xMDIsXLyY+Pt7o2OXLl/PJJ5/w00/arWU9e/YkNTXV5HhLUEok6LAmedFZIuGD1WtIev11Vny8mrbRxktZF5ZVsX3zf3hz5kwu/17bGyMisg3JqancP/JBwHYvgqUo5UVwhEAA2LYpjVNfvk/5tdoE2aaBkfQe8xJt4wbYbV4lEMJAIBAojexdD+vXr2fatGkkJyeTnp5OTEwMQ4cOJT8/3+j4ffv2MXr0aPbu3cvhw4eJiopiyJAhXLp0yej4hlBSJNiywwEcKxIkSWLWW28ze9YbbPgijeEjHjB6e51ImPLUWC7/3p26mfu5l7vz/IQn2Pb1f2R7EWwVCS38vK0WCfV3MdhLJKT/Usi2TWkc/3g25dfuBHT/Ntpw/Wose5ckkX10r13mtgVX3qEgEAjcH9lCYeHChTzzzDNMmDCBLl268MEHH9C0aVM++ugjo+PXrFnD5MmTiY2NpXPnzqxYsQKNRsPu3btlG+tTqK0EqJRIMIW12yDt6Um4Wq7h3LlzbN+1m7vvMV4OWRdueHPmTKSa/gt3Ac2Au5CkNOABZk+fgVqtlh1qkCMSdFsebREIIL8WgjXoGjNJGjVn05ai7fXwVyAHWAZcAEYBI/j+s/9Do3F+/3ghDgQCgaOQFXqoqKjg2LFjTJ8+veaYp6cngwYN4vDhwxbd4/r161RWVhIUZLoZUnl5OeXl5TU/FxfXuq6VFAnW7nAwVSsBlBcJxcXFvLdkGdNee42PVn9qcl5d0uKx7w5VhxvWYaxfgSRNJ/9yAj+nf09cn7tN3g+sCzUoHWawZ4ihfoLi5VPHuH71d7S9K54C/gI8A3wNzAVWUFp4L3lnMp2yzbFuWEEIAoHAuajVEvkF122+T0Vl/eJurocsoVBQUIBarSYsLEzveFhYGKdOnbLoHn//+9+JjIxk0CDTWeLz5s0jJSXF4HhAh9ssmsMWkWDJDgdj2FKaGYyLhLz8fIY9+Ajh4RFUVKrxNvHOrLuzId/C/gu1fRoM0QkEsE4kuLJAMLd7oaymJ0UWcBat2AJIBuKAU/XG2ReRbyAQCFwBh+56mD9/PuvWrWPfvn34+Zne9jd9+nSmTZtW83NxcTFRUVEN3l91o8BmkWDyWguSF41iQf8GYyLhjz8KGTLyIbp06coHy1fi7W385Vt/+2Oohf0Xavs06GOLF8GVExUt6dzYpIWu7PVbaL0JdXoIMLL6eN1xyiPEgUAgcDVkCYXg4GBUKhV5eXl6x/Py8ggPN/7i0bFgwQLmz5/PN998Q/fu3c2O9fX1xdfXeNdDUyglEhTd4WClSAA493s+cXFx/O//LcHLy/ivqbCsyqA+QnyfvkREtiH3cmp1TkLd8IO2/0JYRBt6xPcxuJ8zRIIrCAQdYR1j8WnagorrOcCmeme1XgXfWwIJ6xirqI1CHAgEAldGllDw8fGhZ8+e7N69m8TERICaxMSpU6eavO6dd95h7ty57Nixg7i4OJsMNoYl/RvAPURCaWkpO/YfZuiwYSx+/0Oj15oroqRSqUhOTeX5CU9o+y1I09GGG34Cj3nAZl6ds1qvnoKzchHsGWaQIxBqkCQ8vXyAodT2ENBxBzAUD1UGSJJNtglhIBAI3AnZoYdp06Yxfvx44uLiiI+PZ9GiRZSWljJhwgQAxo0bR8uWLZk3bx4Ab7/9NrNnz2bt2rW0bduW3FxtbLxZs2Ym2yDLQamCSopug7RSJNy4cYOHR4+jSl3FkGHDMVZL0ZJKi/ePfJC573/MopTZ5OfW9isIi2jDq3NWM/D+kTXHnOlFUFogWCUO6pB39jg3ivOBHRjtIQDcKLauZ4MQBwKBwF2RLRRGjRrFlStXmD17Nrm5ucTGxrJ9+/aaBMecnBy9ngNLly6loqKCRx99VO8+ycnJzJkzxybjlejfAApvg7RAJBijsrKSUeOfpqSkmE1fbzXat0FOOeb+wx7gvvsfIOP7wxTk5RIcFk6P+D41ngRrEhZt9SLYK8xgq0DQEdquG/2rezZoJA3FuReoKC3B5xZ/moe3wdPDU1bPBiEOBAJBY8CqZMapU6eaDDXs27dP7+fs7GxrpmgQJURCQzscZG+DtFAkGPMmpO3cw2+//cbXW7bj7294vSUiwVgRJWNbIB3tRXB1gaBDiZ4NQhwIBILGhlv2elBKJNRFrdFwOOsXcouKaRkaSN8u7TD2GjW5DdJKkaDRaMjOv8rw4SO4b9BQo7tBrBUJxmhIJKjVaoMukFn5pYBtIsGVBYIxNBo1eWcyKSsqoEmLYMI6xuLpafjMhDBwPpIkcfXiaQKjOhnteyLQ58eT2c42oUG6d2nrbBMEdXA7oWBr/wYwzEv4+vvjzFq1iZzCopoxbUKCmP/ikyT26107t7ltkMgXCZIk8eLrM/nxx+Ns27kbPz/DX4cjRcKhnVtYNi+FgtycmmMBIa34n1dm0qP/MLP3ro+7CgSA7KN7+W7tP6uLL2mp3+tBFD9yHXLSd3H0s1R6jZ5B655DnG2OWZz9km4X5k+7MNP1XFwFW5+TuqJMGUMEgJsJBc8bf4C3t9X9G8C4SBi/8GMeQFuPr3p/AKlXChnzxkLWvjmNxH69G8xLsEYkJKXMZfPmr9m2c7fJDpDgOJGQ+vJEkPSfxLUrqXw4YzLPpr5vkVhQOszgKHGgI/voXvYuSUJbxvkLdM/h+tW57F2SRPTDMwjs1FeIAxdBo67i5A5txdKTO/5Nq9iBeKqU/VhT+uXuDi9qZ2PrM6oqV3FeIVsEbiYUwPomT2AoEtQaDbNWbULXFUGXPnhX9c+JwPTFq0m8TxvnNxdyMIa5nIQPP1nLmk8/Zcv2XbRp08bgvFIiwZJ8BLVazbJ5KdUiIQ1jT2LDonnE3DMYTyNtqsH9BQJoww3frf0nGP0X8R/gQS7v+ZjYuwY6xB5Bw1zM3MP1wovAMkoLJ/Fb5h6zXgVrX/ri5S64mXEroXDLbYYvVJCXk1A3efFw1i/kFBaxHmNdEWA6kJD/BwczT9K/fz/Dm1rRv6GsrIxSyYuHH3mUfgMGWSUSdAIBbBcJAD8fO1IdbjD9JK7mJ3D2+A90utOw2qOSYQZnCAQdeWcyq8MNX2D8OcygrCiBgvM/EtK+h0NtExhS600YibYnx1dkbP6Yq77t8DCST6JDvPQFAnm4lVAwhrUiASC3SJvJb74rAuSWGintbIVIKCj4g8T/eZz+/Qcw441kmvkH6J13ZKihLj+euVD9nfknUVyg30q8sQgEHaezfq3+zvxzuFFSaOK8wB6Y8gIUn/u22puQVn1kDlUlcTT94ziRdxgR9gKBwCrcWijYWkypZWgg0FBXBIgIuVX/hAmRYC7UcP7XbB54+K906dqVV1573eC80qEGsEwk/HS5GP9bQ3Q/Ye5JNA/WbhdVMszgbIFQNykxKjICrVQw/xz8TDX/EsjGklCAMQ+ARqPmwBdb0HoT6vbkeICzB74gvMvdRnepCAQC+bitULBVJHj7qejbpR1tQoJIvVKoF5EG0ADzPOC2sFDu7lmnN4WJxEVzIkGj0fDw6CcYPGQoc+e/Y1BMydGhBtCvi9CjVx9ahEZRlJ8Kxp8EgaGt6RDTyy5eBEcLBFM7FqTA7jQJiKDs2ly0OQn1n0MqTVpEEhxtvleJoBZrhUBDXP75AGXXfkfbArwucygriiP35EHhVRAIFMIthYISIgHAJySc+S8+yZg3FmoTF6nd9TDPAzYD66e/WNsXwQqRcP7XbMLatmfTf74iLDzS4LylIkGpUIOx6oqeKhWjXp7BhzMmg+GTADZz55h3OHbxmtsKBEvqHXh4qohJfJ4jq5OBB4EZ1NkHA2wh5sEUs/Hvmw17CQFzaDRqzh34AhiG8Z4cw4RXQSBQELcSCl6U4I2PVfkIOuo3eUrs15u1b04j6f9WkXCl1g1+W1go66e/yEODq/8qsUIk/GvlJ8yeNZMjR9Np1cqwTbYSIkFOqMFcdcUe/YfxbOr7rF+USlF+bX+IwNDW3DnmHdrGD1QszOAsgWDJlsaW3e7lrvEpHE9bStm12ufQpEUkMQ+m0LLbvXax09UxJwgcnRx49WJWtTfhd0z15Cgr0o67tY2pfBOBwDaqJImcMiP5azIp19jWZM4RuJVQAOuSFnWY6gSZ2K83iffdzcHMk+SWVhIRcit39+yu9SRYkbQoSRLT/5HKRytWsuGLTXYXCXJDDabo0X8YMfcM5uzxHyguyOdylR9hnXsQ1ty2F7ujBYKtxZBadruXyK59KTj/IzdKCvHzDyI4unuj9yS4khgwR2DLTsQmvopGbfpD2lPlTWDLTg60SiBovLiVUPBrafjCBesFgg5dMSWDLZBWiASAXd9+x+cbN7Ljmz106tzZ4LwjRYLcHg2eKhXFQR0hqCMR2JaL4OhERSWrJXp4qhrlFkh3EQPm8PTyJvz2hIYHCgQCRXAroWAMJUSC3N4NpkTCtWvXOHspn7597+bID+k0bar/srJ0Z4MjQg2mUCJZ0ZECQZRSNk5jEAQCgcA1cGuh4Eoi4XJuLvcnPkr37t35YPlHNG2q/2id4UUAy0WCOwkE0YipFkcIAkmjpvBiFuV/XsW3WSBBUbfbJQzjqHkEAoE83FYo2CISGurbAPJEwsXffmPIA4nE9Ypn8fsfGlznyqEGJWoiOEMg3GziwFkegtzTR8ja9QnlJXk1x3z9w7h98DjCOxmrNeHa8wgEAvm4pVBwJZEAMHfBP7mnXz8WLlpsdY0EUyLBnqEGW70IjhAIN5v3wJVCBrmnj5D55QJgBDAT3VbR8pK5ZH65gNiHX1PkJe6oeQQCgXW4lVDw9a7E19vT5qRFpUTCuV/OExDeinlvv42PbxODDpBKiQSlQw1KehEcIRAaqzgwJQpcIYdA0qjJ2vUJ2pd33eJTtQ2yTu36lLAOvWwKDzhqHoFAYD1uJRTA9p0NSomEH3/6iWEjH+Ifb77FmLHjDa5ztEhwtBdBCAR5uLIoMEbhxazqMMBMTDXIulGSQKGNtQocNY9AILAetxIKXiGGlQ3B8SLh6LF0hic+ytQXX3AbkWCrF8GeYYbGJg7cTRQYo/zPq9XfmW+QVTvOtecRCATW41ZCwRiOFglqtZoJz07m70lJPD/1RYPrCsuqFNn+aE4kONKLIASCeYyJAncSBKbwbRZY/Z35Blm141x7HoFAYD1uLRSsTloEq0TChZwcgqOi2bl7DwEt9O/rqJ0NzhAJQiBoaayiwBhBUbfj6x9GeYnpBll+/uEERd3uFvMIBALrcVuh4GiRsHX7Dh5/8mn2HThEh44d9c4pJRIsEQggL9TgKgLBHcXBzSQM6uPhqeL2weOqdyMYb5DVefBrNicYOmoegeBmZO7cuWzZsoXMzEx8fHwoKiqy6j5uJxRsCjWAVSJh45ebeOb5qSz9cLniIsGVvAj2CDO4k0C4mYWBMcI73UXsw69V1zeoLZns5x9O58HKbVl01DwCwc1GRUUFf/3rX+nTpw8rV660+j5uJRS8/bRuSaXzEcC0SPjplxyee+FlVn26hiFDh+mdaywi4WYVCEIYNEx4p7sI69DL7hUTHTWPQHAzkZKSAsCqVatsuo9bCQUwH2oA60WCsQ6Qpy/mclt0NBnHfyI4JETvvL1FgqO9CDeLQKgvDoQwaBgPT5VDtiY6ah6BwNWorKykuLhY75ivry++vr5OskgftxIKqsAQw2N2CDVUVVXx/Ct/Iz09nf8ePNwoRcLNJBDqigMhDAQCga00bdqU0qoK8m6U46eyvOlefdSShsLyMrZv385TTz2ldy45OZk5c+bYaKkyuJVQqI89REJZWRljnprEL+fO8XnaV7JKMiuxs8HetRGUDjPoBIIriwMQAkEgEChHjx49iGwawP7cXxjSsrPV9zlWcBEPD1ixYgXLly/XO2fKm5CUlMTbb79t9r5ZWVl07my9XfVxW6Fgj3wEgHf/9QFXrlxh287dBAZZvgVSyZ0N9trVoKQXwRU9CEIcCAQCR+Dh4cH63du4u08CvUPaEOAj/zO1XF3F7t/PsGrdGvz9Lf+sevXVV3nyySfNjomOjpZtjzncTijY4kUA822iadKcF158iclTX6JpU/2Xny0iQemkRbkiQUkvgqsJBCEOBAKBM4iPj6dzQBjf/H6GR9rGyL7+YN55gnyb8vDDD8u6LiQkhJAQwzC8PXEroaDysY9IOHP2HMMfepRJzz7L1BdfMbjOVUSCq3gRnC0QhDgQCASuQNrRA3Rq34G+obcR3rS5xdeVVN7gYN4v7D2w36CZoJLk5ORQWFhITk4OarWazMxMANq3b0+zZs0svo9bCQVQNh8BtH0bRj7yGE+MG8eUF142OG+uJLMjkxadKRJcQSAIcSAQCFyN6Ohoeoe0YfulLJ7s0Nvi63b/foYOzUNISEhoeLANzJ49m9WrV9f83KNHDwD27t1L//79Lb6PWwkFD38j9d5tyEfQaDQ8M/Ulpr36GlNefFnvnCvtbLA21ODuYQYhDgQCgavzVdZRWoaGc674Cu2bNxwSyC8rIeOP3zh5+pTdbVu1apXNNRTAzYSCATaIhMwfT9ChWw927t7HLbfconfOVUSCs7wIriQQhDgQCASuTFBQEP3D27Pttyym3B6MZwOhhO2XsogLbk2HDh0cZKHtuK9QsCDUAMa7P854cx4rli3j2+9+oHXrNnrnbREJzsxHcHeBIMSBQCBwVzadSyciIIjjhZfocWsrk+POlxSQXVLIgdyfHGid7bifUGhS+9e/3HyEP/4oZMyEZ/jtt4t8s3e/VSLBFZMWlRQJjhQIIrQgEAgaA35+fvzro+VMmTCROwIj8DZSelwjSWz/LYt7w9s5fNeCrbiXUPDTvsSsCTUAHMo4QfOA5uxec5DmzfUzVO25s8Fe+QhKbHt0tkAQ4kAgEDQGRo8ezeuTpnAo/1f6hbc3OH/i6u+UVJaTdjbdCdbZhnsJBawTCas/XUNIqzYMvO8+7hs81OC8K4gER3sRHB1mEOJAIBA0Zjw9Pfn35k3cP2gIcbdGcYt3bWXFKo2aXZdO8c9lSw1q9LgDbiUUPPwM932aEwjl5eW88PoMvkpL4+NP1uDhabhcdxMJtnoRGhIIkkZNwfkfuVFSiJ9/EMHR3a3u4CdCCwKB4GZiwIABtPUPYu/lszzQurbB2ZEr2fiqvBg7dqwTrbMeq4TCkiVLePfdd8nNzSUmJobFixcTHx9vcvzGjRt54403yM7OpkOHDrz99tsMHz7caqN1mBMJf/75J0NGPoRareG/3x4mKqq1wRh3FQn2CjNcOrGf42lLKbt2ueZYk4AIYhKfp2W3ey2fR3gPBALBTcoX3+4htlt3+oTexq1+t3C9qoK9l8+RtuVrVCr3bJvu2fAQfdavX8+0adNITk4mPT2dmJgYhg4dSn5+vtHxhw4dYvTo0Tz99NNkZGSQmJhIYmIiP/1kW9anOZFQUVEBTQN48qmn2LZr900vEn48U2CRSDiyOpmya3HAYaAEOEzZtZ4cWZ3MpRP7zc9xMrvmq12Yf82XQCAQ3Ex07dqV2FtbsvOStk7Cf3PP0appAEOHGoa93QUPSZIkORf07t2bXr168a9//QvQFi2KiorihRdeICkpyWD8qFGjKC0tZfPmzTXH7rrrLmJjY/nggw8smrO4uJiAgAAKz6TT3N/fpEiQJIl3Fi9l44YN7P3vflRehi9gd6uRYG8vAmjDDdvmPlEtEtLQ148a4EGatEjn/hmfGoQhhPdAIBC4GlXl1/lm4ViuXbtmkLjuCC5fvkzbVlEktunOl9nHOZqh/aPaXZEVeqioqODYsWNMnz695pinpyeDBg3i8OHDRq85fPgw06ZN0zs2dOhQ0tLSTM5TXl5OeXl5zc/Xrl0DoKgc1D4SHpoK7YmyipoxlZVVPPPCyxw9epRlKz6i9PoN4Ibefa/eqBYJJgpiXC7Rzunt5UmFkfPZV8sArUi4Xm/AydwSAAL8tI+0rFR/bh3pF64CEFwtEMrr36gOx3/Vjo0I8KOi7E+T44zx87naXIbWQU2ovFFqcmzB+R+rww0vAcbmeYmyosHknvqe4OjuAPx0KqfmbHSoVrhVlV+XZaNAIBDYg6py7We1zL+DFSMiIoK+YdFs/DWD2FtbubVIAJlCoaCgALVaTVhYmN7xsLAwTp0yXo4yNzfX6Pjc3FyT88ybN4+UlBSD49Hd7rTIzr+MuN+icTcLmRaPHGT27KGPphs9fl6OMQKBQOAgSkpKCAgIcMrcX51J5/72MXx29L9OmV9JXHLXw/Tp0/W8EEVFRbRp04acnByn/dKVpri4mKioKC5evOgU15g9aGxramzrAbEmd0GsyTYkSaKkpITIyEi7zmOOZs2acSD3F6fNrySyhEJwcDAqlYq8vDy943l5eYSHhxu9Jjw8XNZ4AF9fX3x9fQ2OBwQENJr/NDqaN28u1uTiNLb1gFiTuyDWZD2N5Y9KV0DWrgcfHx969uzJ7t27a45pNBp2795Nnz59jF7Tp08fvfEAu3btMjleIBAIBAKB6yA79DBt2jTGjx9PXFwc8fHxLFq0iNLSUiZMmADAuHHjaNmyJfPmzQPgpZdeol+/frz33nuMGDGCdevWaRMOly1TdiUCgUAgEAgUR7ZQGDVqFFeuXGH27Nnk5uYSGxvL9u3baxIWc3Jy8PSsdVQkJCSwdu1aZs2axYwZM+jQoQNpaWnccccdpqYwwNfXl+TkZKPhCHdFrMn1aWzrAbEmd0GsSeBKyK6jIBAIBAKB4OZBdmVGgUAgEAgENw9CKAgEAoFAIDCJEAoCgUAgEAhMIoSCQCAQCAQCk7iMUFiyZAlt27bFz8+P3r178/3335sdv3HjRjp37oyfnx/dunVj69atDrLUcuSsafny5dxzzz0EBgYSGBjIoEGDGnwGjkbu70jHunXr8PDwIDEx0b4GWoHcNRUVFTFlyhQiIiLw9fWlY8eOLvdvT+6aFi1aRKdOnWjSpAlRUVG88sor3LhhvFeJM9i/fz8jR44kMjISDw8Ps31idOzbt48777wTX19f2rdvz6pVq+xupxzkrunLL79k8ODBhISE0Lx5c/r06cOOHTscY6yFWPN70vHtt9/i5eVFbGys3ewTWI9LCAVXaV2tJHLXtG/fPkaPHs3evXs5fPgwUVFRDBkyhEuXLjnYcuPIXY+O7OxsXnvtNe655x4HWWo5ctdUUVHB4MGDyc7O5vPPP+f06dMsX76cli1bOthy08hd09q1a0lKSiI5OZmsrCxWrlzJ+vXrmTFjhoMtN01paSkxMTEsWbLEovG//vorI0aMYMCAAWRmZvLyyy8zceJEl3qxyl3T/v37GTx4MFu3buXYsWMMGDCAkSNHkpGRYWdLLUfumnQUFRUxbtw47rvvPjtZJrAZyQWIj4+XpkyZUvOzWq2WIiMjpXnz5hkd/9hjj0kjRozQO9a7d2/p2WeftaudcpC7pvpUVVVJ/v7+0urVq+1loiysWU9VVZWUkJAgrVixQho/frz04IMPOsBSy5G7pqVLl0rR0dFSRUWFo0yUjdw1TZkyRRo4cKDesWnTpkl9+/a1q53WAkibNm0yO+b111+Xunbtqnds1KhR0tChQ+1omfVYsiZjdOnSRUpJSVHeIAWQs6ZRo0ZJs2bNkpKTk6WYmBi72iWwDqd7FHStqwcNqu1caEnr6rrjQdu62tR4R2PNmupz/fp1KisrCQoKspeZFmPtev7xj38QGhrK008/7QgzZWHNmr766iv69OnDlClTCAsL44477iA1NRW1Wu0os81izZoSEhI4duxYTXji/PnzbN26leHDhzvEZnvg6p8PSqDRaCgpKXGJzwdb+Pjjjzl//jzJycnONkVgBqd3j3RU62pHYs2a6vP3v/+dyMhIgw88Z2DNeg4ePMjKlSvJzMx0gIXysWZN58+fZ8+ePTz++ONs3bqVc+fOMXnyZCorK13ig86aNY0ZM4aCggLuvvtuJEmiqqqK5557zqVCD3Ix9flQXFxMWVkZTZo0cZJlyrFgwQL+/PNPHnvsMWebYjVnz54lKSmJAwcO4OXl9FeRwAxO9ygIDJk/fz7r1q1j06ZN+Pn5Odsc2ZSUlDB27FiWL19OcHCws81RDI1GQ2hoKMuWLaNnz56MGjWKmTNn8sEHHzjbNKvZt28fqampvP/++6Snp/Pll1+yZcsW3nzzTWebJjDB2rVrSUlJYcOGDYSGhjrbHKtQq9WMGTOGlJQUOnbs6GxzBA3gdBnnqNbVjsSaNelYsGAB8+fP55tvvqF79+72NNNi5K7nl19+ITs7m5EjR9Yc02g0AHh5eXH69GnatWtnX6MbwJrfUUREBN7e3qhUqppjt99+O7m5uVRUVODj42NXmxvCmjW98cYbjB07lokTJwLQrVs3SktLmTRpEjNnztTr2+IumPp8aN68udt7E9atW8fEiRPZuHGjS3gbraWkpISjR4+SkZHB1KlTAe1nhCRJeHl5sXPnTgYOHOhkKwU6nP4p0BhbV1uzJoB33nmHN998k+3btxMXF+cIUy1C7no6d+7MiRMnyMzMrPn6y1/+UpOFHhUV5UjzjWLN76hv376cO3euRvQAnDlzhoiICKeLBLBuTdevXzcQAzohJLlpGxhX/3ywls8++4wJEybw2WefMWLECGebYxPNmzc3+Ix47rnn6NSpE5mZmfTu3dvZJgrq4uRkSkmSJGndunWSr6+vtGrVKunkyZPSpEmTpBYtWki5ubmSJEnS2LFjpaSkpJrx3377reTl5SUtWLBAysrKkpKTkyVvb2/pxIkTzlqCAXLXNH/+fMnHx0f6/PPPpcuXL9d8lZSUOGsJeshdT31ccdeD3DXl5ORI/v7+0tSpU6XTp09LmzdvlkJDQ6W33nrLWUswQO6akpOTJX9/f+mzzz6Tzp8/L+3cuVNq166d9NhjjzlrCQaUlJRIGRkZUkZGhgRICxculDIyMqQLFy5IkiRJSUlJ0tixY2vGnz9/XmratKn0t7/9TcrKypKWLFkiqVQqafv27c5aggFy17RmzRrJy8tLWrJkid7nQ1FRkbOWYIDcNdVH7HpwXVxCKEiSJC1evFhq3bq15OPjI8XHx0tHjhypOdevXz9p/PjxeuM3bNggdezYUfLx8ZG6du0qbdmyxcEWN4ycNbVp00YCDL6Sk5Mdb7gJ5P6O6uKKQkGS5K/p0KFDUu/evSVfX18pOjpamjt3rlRVVeVgq80jZ02VlZXSnDlzpHbt2kl+fn5SVFSUNHnyZOnq1auON9wEe/fuNfp/Q7eO8ePHS/369TO4JjY2VvLx8ZGio6Oljz/+2OF2m0Pumvr162d2vCtgze+pLkIouC6izbRAIBAIBAKTOD1HQSAQCAQCgesihIJAIBAIBAKTCKEgEAgEAoHAJEIoCAQCgUAgMIkQCgKBQCAQCEwihIJAIBAIBAKTCKEgEAgEAoHAJEIoCAQCgUAgMIkQCgKBQCAQCEwihIJAIBAIBAKTCKEgEAgEAoHAJEIoCAQCgUAgMMn/AwsEyysVbvyfAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure()\n",
        "cm = plt.cm.RdBu\n",
        "\n",
        "# make data for decision regions\n",
        "xx, yy = np.meshgrid(np.linspace(0.0, 1.5, 20), np.linspace(0.0, 1.5, 20))\n",
        "X_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())]\n",
        "\n",
        "# preprocess grid points like data inputs above\n",
        "padding = 0.3 * np.ones((len(X_grid), 1))\n",
        "X_grid = np.c_[np.c_[X_grid, padding], np.zeros((len(X_grid), 1))]  # pad each input\n",
        "normalization = np.sqrt(np.sum(X_grid ** 2, -1))\n",
        "X_grid = (X_grid.T / normalization).T  # normalize each input\n",
        "features_grid = np.array(\n",
        "    [get_angles(x) for x in X_grid]\n",
        ")  # angles for state preparation are new features\n",
        "predictions_grid = [variational_classifier(weights, bias, f) for f in features_grid]\n",
        "Z = np.reshape(predictions_grid, xx.shape)\n",
        "\n",
        "# plot decision regions\n",
        "cnt = plt.contourf(\n",
        "    xx, yy, Z, levels=np.arange(-1, 1.1, 0.1), cmap=cm, alpha=0.8, extend=\"both\"\n",
        ")\n",
        "plt.contour(\n",
        "    xx, yy, Z, levels=[0.0], colors=(\"black\",), linestyles=(\"--\",), linewidths=(0.8,)\n",
        ")\n",
        "plt.colorbar(cnt, ticks=[-1, 0, 1])\n",
        "\n",
        "# plot data\n",
        "plt.scatter(\n",
        "    X_train[:, 0][Y_train == 1],\n",
        "    X_train[:, 1][Y_train == 1],\n",
        "    c=\"b\",\n",
        "    marker=\"o\",\n",
        "    edgecolors=\"k\",\n",
        "    label=\"class 1 train\",\n",
        ")\n",
        "plt.scatter(\n",
        "    X_val[:, 0][Y_val == 1],\n",
        "    X_val[:, 1][Y_val == 1],\n",
        "    c=\"b\",\n",
        "    marker=\"^\",\n",
        "    edgecolors=\"k\",\n",
        "    label=\"class 1 validation\",\n",
        ")\n",
        "plt.scatter(\n",
        "    X_train[:, 0][Y_train == -1],\n",
        "    X_train[:, 1][Y_train == -1],\n",
        "    c=\"r\",\n",
        "    marker=\"o\",\n",
        "    edgecolors=\"k\",\n",
        "    label=\"class -1 train\",\n",
        ")\n",
        "plt.scatter(\n",
        "    X_val[:, 0][Y_val == -1],\n",
        "    X_val[:, 1][Y_val == -1],\n",
        "    c=\"r\",\n",
        "    marker=\"^\",\n",
        "    edgecolors=\"k\",\n",
        "    label=\"class -1 validation\",\n",
        ")\n",
        "\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PQxSiY4ZyqM4"
      },
      "source": [
        "About the author\n",
        "================\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since end of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "P2zpMNTeG-uN",
        "outputId": "ac0352b7-15aa-4e18-9954-1d03d2b6d15c"
      },
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1693428612.1869953\n",
            "Wed Aug 30 20:50:12 2023\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.17"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}